A veteran developer reflects on a 23‑year career spent outside the conventional software‑engineering label, questioning the rise of AI agents that promise to write code for us. He argues that reproducibility, readability, and critical dialogue remain essential, and that the industry’s rush toward opaque, agent‑centric pipelines risks eroding the very craftsmanship that keeps software trustworthy.
Thesis
After more than two decades of writing code without ever earning the badge of software engineer, I have come to suspect that the most urgent skill for the coming "agentic" era is not the ability to command a large language model, but the capacity to insist on clarity, reproducibility, and human‑centered reasoning. The prevailing narrative—that AI agents will make hand‑written code as obsolete as COBOL—overlooks the fragile foundations upon which reliable systems are built.
Key Arguments
1. Reproducibility cannot be delegated to stochastic generators
When a program is compiled, the expectation is that the same source, given the same inputs, yields the same behavior. Large language models, by design, introduce nondeterminism: the same prompt can produce divergent snippets on different runs. If we allow such generators to author production code, we inherit a moving target where debugging becomes a game of chasing phantom changes. The result is a loss of the deterministic contract that underpins testing, version control, and regulatory compliance.
2. Readability remains a human contract, not a machine convenience
Code that reads like a well‑structured essay enables peer review, onboarding, and future maintenance. A model‑generated function may solve a problem today, but without intentional naming, documentation, and modularization it becomes a black box. The author’s lament—"code should be readable and comprehensible to software engineers (which I remind you I am not)"—highlights a crucial point: readability is a social contract among developers, not a feature that can be outsourced to an AI.
3. Architectural discipline cannot be replaced by prompt engineering
The author cites concrete anti‑patterns: exposing a dependency‑injection container as a public static member, configuring services via CSV for business convenience, and neglecting explicit interfaces. These are not merely stylistic quirks; they violate principles such as Inversion of Control and separation of concerns. An AI that stitches together subqueries or aggregates without understanding the performance implications will produce systems that are fragile at scale.
4. Metrics‑driven AI adoption masks deeper ethical concerns
The push to track AI usage through KPIs reflects a corporate mindset that treats intelligence as a consumable commodity. This reduces complex socio‑technical impacts—like data provenance, model bias, and the exploitation of training data—to a single efficiency number. The author’s discomfort with “intelligence too cheap to meter” underscores the moral hazard of commodifying cognition without accountability.
5. The “agentic user flow” myth ignores human decision‑making
Proposals to replace dropdown menus with free‑form natural‑language prompts promise flexibility, yet they often sacrifice predictability and accessibility. When a user can type anything, the system must either constrain the input (re‑introducing the dropdown logic) or risk misinterpretation, leading to errors that are hard to trace. The supposed advantage of “agentic” interfaces dissolves without rigorous validation and clear fallback paths.
Implications
- Tooling must enforce determinism – Build pipelines that lock model outputs into version‑controlled artifacts, accompanied by exhaustive tests that verify functional equivalence across runs.
- Education should re‑emphasize software craftsmanship – Courses and onboarding programs need to stress naming conventions, modular design, and explicit contracts, even when AI assistance is permitted.
- Governance frameworks are essential – Organizations should adopt policies that require human review of any AI‑generated code before it enters production, treating the model as a suggestion engine rather than an author.
- Performance profiling must stay human‑centric – Automated query generation should be paired with tools that surface cost estimates, allowing engineers to intervene before costly regressions appear.
- Ethical audits of AI pipelines – Companies must evaluate where training data originates, how models are fine‑tuned, and who bears responsibility for downstream failures.
Counter‑Perspectives
Proponents argue that AI agents will democratize development, allowing non‑engineers to build functional applications rapidly. They point to successful low‑code platforms where business users construct workflows without writing a line of code. While this democratization is valuable, it does not eliminate the need for a guardrails layer staffed by individuals who understand the underlying systems. Without such oversight, the promise of speed collapses under the weight of technical debt and security vulnerabilities.
Another critique is that deterministic output is a feature of the current generation of models, not an inherent limitation. Researchers are exploring techniques such as seeded sampling and model distillation to produce repeatable results. However, even with reproducibility, the deeper issues of architectural soundness and ethical stewardship remain untouched.
Conclusion
The author’s self‑identification as “not a software engineer” is less an admission of inadequacy than a reminder that the industry’s rush toward AI‑driven code generation risks sidelining the very practices that keep software trustworthy. The future will likely be a hybrid: agents that accelerate routine scaffolding, paired with disciplined engineers who enforce readability, deterministic behavior, and ethical accountability. Embracing the technology without preserving these human anchors would turn the promised efficiency into a fragile illusion.
Relevant resources:
Comments
Please log in or register to join the discussion