AI agents now write production code.
QCon London 2026: AI Agents Write Your Code — What’s Left for Humans?
AI agents now write production code.
This is the core insight: autonomous coding agents are systems that read specifications, use **large language models** and tool plugins to generate code, execute tests, and iterate until something usable exists, and while they remove a lot of rote work they leave architecture, ethics, and strategic decisions to humans.
What changes for engineers?
Key Takeaways:
- AI agents automate mundane coding tasks but not stewardship of design.
- Humans remain vital for architecture, ethics, and complex problem solving.
- Build processes that require human review, tests, and moral checks.
What is AI agents writing code?
AI agents mean autonomous programs.
They combine **language models**, tool plugins, scripted planners, and CI hooks so they can read a prompt or issue, produce code, run tests, and iterate while interacting with external tools like repos and test runners—this gives them the ability to complete many dev tasks without continuous human input.
How capable are they?
These systems rely on components such as **large language models**, tooling frameworks like LangChain, GitHub integrations, and model providers, and they function as orchestrators that call code-generation endpoints then validate outputs with unit and integration tests run in sandboxes.
Are they ready for production?
I watched a QCon London 2026 demo where an agent rebuilt a small service, executed test suites, and opened a pull request without a human touching the keyboard, and the demo showed both promise and obvious brittle behavior when the spec lacked nuance.
Did it do things perfectly? No.
When I worked at Google and later at Microsoft and Amazon, shipping code was more than committing files; it was about trade-offs, safety, and long-term maintainability, and the same principles apply when agents write code—they follow instructions literally and don’t infer implicit organizational norms.
Are we comfortable letting an automated chain choose latency vs. cost trade-offs yet? Not fully.
Core Benefits/Importance
AI agents free developers from repetitive work.
They can scaffold endpoints, generate test stubs, handle trivial bug fixes, and produce consistent boilerplate across teams, which speeds up prototypes and lets engineers focus on higher-value problems like architecture, resilience, and user needs.
Sounds good?
There are practical benefits: quicker prototyping, fewer manual errors in boilerplate code, and faster onboarding for junior engineers who receive working examples and tests quickly, and teams can reallocate time to observability and product fit rather than rote coding tasks.
Will they replace senior engineers? No.
I used agent-like systems in a previous role to bootstrap a telemetry pipeline where an automated generator produced initial code and tests; the team then spent cycles on scaling, alerting, and data correctness rather than on plumbing—this saved weeks of repetitive work.
Did it save time? Absolutely.
Agents also expose weak points: they make clear the need for **good tests**, explicit specifications, and strong CI pipelines, because unattended agents will follow the spec literally rather than apply contextual judgment.
Who owns the spec? Humans must.
Step-by-Step Implementation/Guide
Start small and prove value.
Pick low-risk targets like tooling scripts, infra-as-code, or well-covered microservices to experiment with agents, and set clear goals—reduce PR churn, generate unit tests, or handle triage—with metrics to measure success such as change lead time and defect rate.
Ready to try?
1. Create a minimal, precise spec: write clear acceptance criteria, API examples, and tests that an agent can run; the agent will be literal, so the clearer the spec the better the output—treat this as part of your shared documentation.
Do the work once.
2. Wire a language model to tooling: pick a model provider, select an agent framework like LangChain or build minimal orchestration that allows the model to run unit tests in a sandbox and create branches in Git with limited permissions.
Want to avoid disasters?
3. Add gating and permissions: require human PR approvals and automated safety checks, disallow direct pushes to production branches, and add role-based rules so agents can’t escalate privileges or modify access controls—security matters.
Will this slow automation? Yes, but prudently.
4. Monitor and iterate: log agent actions, capture diffs and explanations, run canary releases when appropriate, and measure quality via bug rate and lead time; agents produce output quickly, but you must validate correctness and intent.
Ready to iterate?
I ran an experiment where an agent fixed flaky tests overnight, opened a PR, and included an explanation for the change that saved a developer hours of debugging; the team only merged after small manual edits and an added test to capture a corner case.
Did the process work? It did.
Comparison Table
Direct comparison of core roles and strengths is useful when deciding where to apply agents versus human effort.
| Feature / Role | **AI Agents** | **Human Developers** |
|---|---:|---:|
| Speed on boilerplate | Fast, automated | Slower, manual |
| Architectural design | Weak, literal | Strong, contextual |
| Ethical judgment | Absent without rules | Present, values-guided |
| Complex debugging | Limited | Expert-level |
| Compliance & policy | Needs human rules | Interprets context |
Which should you use where? Use agents for repeatable, well-tested tasks and humans where context, ethics, and systems thinking matter most.
Clear boundaries reduce risk.
Common Mistakes to Avoid
Trusting agent output blindly is common and dangerous.
Teams often accept a green CI and merge automatically without inspecting diffs or the tests themselves—this means agents can institutionalize bad practices quickly if the test suite is shallow or the spec is ambiguous.
Want chaos?
Another frequent error is granting agents wide repository permissions and letting them push to main branches or trigger deployments; convenience combined with insufficient audit trails is a recipe for accidental outages or compliance violations.
Control access.
I remember a late-night incident where an agent reverted a migration due to a timestamp misinterpretation and our rollback logic was brittle; we spent hours undoing the side effects and it was a painful reminder that machines do exactly what you ask, not what you mean.
Learn from that.
Teams also fail to instrument agent activity: without observability you cannot understand why an agent chose a particular refactor or how many regressions it introduced, so add logging, diff histories, and rationale capture to every PR created by an agent.
Sound familiar?
Frequently Asked Questions
Q: Can AI agents replace senior engineers?
A: Not fully, because senior engineers provide system design, ethical judgment, and trade-off decisions that agents cannot reliably make without explicit constraints and values baked into rules—agents are assistants, not architects.
Is that surprising?
Q: Are agents safe for production?
A: Only with strict controls: gated PRs, human approvals, permission limits, robust tests, and audit logging; without those safeguards the risk of silent failure or policy violations rises dramatically.
Want safety?
Q: Which tools power modern agents?
A: The stack commonly involves **large language models** from model vendors, frameworks like LangChain, GitHub Copilot integrations (GitHub Copilot), and CI/CD systems that allow sandboxes and automated test execution—compose them carefully.
Ready to build?
Internal resources: For internal guidance, start with your engineering best practices pages such as engineering best practices, tool reviews like AI coding tools, and leadership guidance at engineering leadership to set policy and governance.
Final Thought
AI agents are powerful assistants, not replacements.
I’ve seen them speed up boilerplate and prototype delivery at past roles, and I’ve also seen them make literal choices that caused late-night fixes, and this balance teaches a simple duty: steward your tools well, require human checks where judgment matters, and treat work as a dignified craft that deserves care beyond mere speed.
Sincerely, Ermenildo V Castro