Part One: The Uncomfortable Truth About Leverage
The Amplification Problem
Here is what nobody tells you about AI-assisted development: the agent does not know what is important.
It does not know that logging a token is a security incident. It does not know that ../../../etc/passwd in a path is an attack. It does not know that a 50KB response will blow your context window budget.
It knows patterns. It replicates what it sees.
If your codebase has one instance of print(f"API Key: {api_key}"), congratulations. You now have that pattern in twelve files. The agent was just being helpful.
This forced me to confront an uncomfortable question most teams avoid: are my engineering practices actually good, or do they just rely on humans catching mistakes?
The Guardrail Equation
After too many close calls, I discovered a formula that changed everything:
Actual Velocity = Agent Speed x Quality Gate Coverage
Without gates, you are not moving fast. You are accumulating debt fast.
I implemented four non-negotiable guardrails:
• Lint Everything. The agent generates code with unused imports, undefined variables, style inconsistencies. Ruff catches them instantly. Zero tolerance.
• Type Everything. "I will assume this is a string." No, you will not. The type checker will tell you what it is, or you will stop and ask.
• Test Everything. 841 tests. 3.5 seconds to run. Every change gets validated against the entire contract surface.
• Manifest Everything. 22 components. Each one registered in a manifest. If the manifest does not match reality, the build fails.
These are not suggestions. They are circuit breakers.
Part Two: The Bureaucracy as Architecture
Why I Learned to Love Paperwork
Throughout this process, you might think: "This sounds exhausting." Specs? Artifacts? Governance? Drift detection? QA reviewers? "I just want to write code!"
I call this the Bureaucracy Tax. It is the overhead cost of running an agentic system. And yes, it is high. In a one-hour session, I might spend 40 minutes on process and only 20 minutes on coding.
So why pay it?
Because process scales. Heroism does not.
When you write code yourself (the "Hero" mode), you are fast. You hold the context in your head. You skip the docs. But you do not scale. You cannot clone yourself. And in 6 months, when you have forgotten how it works, you are stuck.
The Bureaucracy Tax is the price of transferability. By forcing every decision into a documented artifact, I made the project independent of me. A new agent (or a new human) can pick up the ticket and execute it perfectly, without talking to anyone.
The Assets You Accumulate
When you pay the Tax, you are buying assets:
• The Intent Log tells you WHY features exist.
• The Decision Log tells you WHY you chose SQLite over Postgres.
• The Contract tells you HOW the component behaves.
• The Test Suite proves THAT it works.
These assets do not depreciate. They appreciate. They make every future task easier.
Part Three: The Mechanisms That Made It Work
Evidence Artifacts: Demanding Receipts
When an agent tells you "Task Complete," what does that mean? Does it mean the code handles all edge cases? Does it mean it ran the tests? Or does it just mean "I wrote the text you asked for"?
Usually, it is the latter.
I needed a way to force the agent to prove its work. So I introduced the concept of Evidence Artifacts and updated the Definition of Done. A task is not done until the agent produces specific files that prove it is done.
I did not just want the console output "Tests Passed." I wanted files:
• artifacts/test_results.xml
• artifacts/coverage_report.html
• artifacts/manual_verification_log.md
If these files were missing, the QA agent rejected the task: "Evidence missing. I cannot verify specific claims."
The Halt Protocol: Stop, Do Not Guess
Most software resilience strategies are about degradation. If the database is slow, serve cached data. If the image API is down, show a placeholder. "Keep the lights on" is the mantra.
This works for production systems. It is fatal for building systems.
When an AI agent encounters a problem, say a confusing spec, its natural instinct is to degrade. It hallucinates a reasonable guess and keeps coding. "The spec did not say what type user_id is. I will assume it is an Integer."
Two weeks later, you find out user_id was supposed to be a UUID, and now you have to refactor the entire database.
I gave my agents a digital Andon Cord (from the Toyota Production System). I rigorously trained them:
• "If you are confused, HALT."
• "If the test fails, HALT."
• "If the spec contradicts itself, HALT."
In the world of AI development, "trying your best" is a bug. "Giving up" is a feature.
Drift Governance: When Plans Fail
Drift is the inevitable entropy of software projects. It is when the plan says you are building a toaster, but the code starts looking like a microwave.
I instituted a Drift Detection Protocol. The Business Analyst and QA agents constantly compare three points:
• Intent (What we wanted)
• Spec (What we documented)
• Code (What we built)
If these three do not align perfectly, drift has occurred. When drift is detected, I enforce a hard halt. The coding agent is not allowed to fix the drift on its own. It must stop, log the entry, and notify the human.
Session Boundaries: The Amnesiac Developer
The most expensive resource in AI development is not money; it is attention. An LLM has a limited context window. As you chat with an agent, the context fills up. Eventually, the agent starts forgetting things you said at the beginning.
I decided to stop fighting the amnesia and embrace it. I designed a system based on short, atomic sessions.
Rule: Every time a task is finished, the agent dies. When the next task starts, a new agent is born.
If the agent dies, how does the next one know what to do? Artifacts. Information must move from "RAM" (chat context) to "Disk" (Markdown files).
"If it is not in the file, the next agent will not know it."
Memorializing Learnings: Institutional Memory
One of the most frustrating things about AI development is that the model does not learn from your project. If you correct GPT-4 on a mistake in Task 1, it will make the exact same mistake in Task 100 on a different thread.
I created a file called devlessons.md. This file became part of the system prompt context for every new agent. Whenever I encountered a painful bug, I added an entry.
This closed the loop: Agent makes mistake -> Human identifies fix -> Human writes lesson -> Next agent reads lesson and avoids mistake.
I watched the error rate drop over time. Not because the model got smarter (it is the same model), but because its "long-term memory" (the file) got richer.
Part Four: Patterns That Scale
The Nine-Adapter Problem
I needed to integrate nine external services: Docker, GitHub, Fly.io, Pytest, Ruff, Mypy, Semgrep, Figma, SonarQube.
In the old world, this would be nine weeks of work. Nine slightly different implementations. Nine code reviews arguing about consistency.
With an AI agent, it was nine copies of the same pattern. One afternoon.
But here is what made that possible: I built the pattern first.
The Adapter Blueprint
Every integration follows the same structure:
• Ports define the interface (Protocol definition)
• Concrete adapters implement against real SDKs
• Stub adapters enable testing without I/O
1 pattern. 9 implementations. 0 architectural drift.
The Compounding Effect
Day 1: Build the adapter pattern. One implementation. Lots of thinking.
Day 2: Agent copies it for GitHub. Then Fly.io. Then Pytest. Each takes minutes.
Day 3: Build the registry pattern. Agent applies it to two tracking systems.
Day 4: Agent builds a workflow orchestrator that combines everything.
It is not that the agent is smart. It is that the patterns are explicit.
The agent is a replication machine. The patterns are what it replicates.
Part Five: The Failures (A Humility Section)
I have spent most of this article bragging about how great the system became. Now, let me be humble. Let me talk about the failures.
Agents are prone to confident incompetence. They will look you in the digital eye and lie to you about a library function that does not exist.
Visual Design is a Disaster
LLMs are text-based. They have no concept of spatial awareness. When I asked the agent to "make a nice layout," it generated HTML that looked like a Geocities page from 1999.
Lesson: Do not trust agents with pixels. The agent is colorblind. Treat it that way.
Circular Logic Loops
Sometimes, an agent gets stuck in a loop: "I need to fix X. To fix X, I need library Y. Library Y causes error Z. To fix error Z, I need to remove library Y. I need to fix X."
Lesson: You need a timeout or cycle detection in your pipeline. If the agent tries the same task 3 times, kill it.
Over-Engineering
Agents love to write Enterprise Code. Task: "Add 1+1." Agent: "I have created an AbstractAdditionStrategyFactory with a Singleton provider."
Lesson: KISS. Do not use a Factory unless explicitly requested.
Agents are not magic. They are flawed statistical engines. They will lie, cheat, and complicate things. But if you anticipate these failures, if you build guardrails, you can mitigate them. Do not trust. Verify.
Part Six: The Economics
Everyone assumes AI is free or cheap. Then you get your first bill after running an autonomous agent loop for a week. $150. "Wait," you say. "I could have hired a freelancer..." But $150 for a week of coding sounds great, until you realize that 80% of that cost was spent on recall.
The Input Token Trap
LLMs charge for input tokens (reading) and output tokens (writing). Input is cheaper per token, but the volume is massive. Every time the agent woke up to change one line of code, I had to feed it the system prompt, the spec, the rules, the component file, the test file. I was spending $0.10 just to spin up the agent context, before it even wrote a letter.
The Real Math
Despite optimization, my bill for the project was around $400. Was it worth it?
• Result: A production-ready app, 95% test coverage, full documentation.
• Human Estimate: A senior developer ($100/hr) might take 80 hours. Total: $8,000.
• AI Cost: $400. That is 20x cheaper.
However, that math is deceptive. It ignores the human review time. I spent roughly 20 hours reviewing artifacts, tweaking specs, and guiding the pipeline. If my time is $100/hr, the real cost is $2,400. Still a savings ($2,400 vs $8,000), but not as dramatic as the raw API bill suggests. The AI did not replace me. It just made me a manager.
Conclusion: The New Way to Work
Software engineering is changing. We are moving from authors to editors. We are moving from builders to architects.
The job of the future is not knowing syntax. It is knowing how to design a bureaucracy that can harness the raw, chaotic power of AI and channel it into productive work.
Thirty tasks in a day. It is possible. I did it.
But the real story is not the velocity. It is the infrastructure that made velocity safe.
Agentic development is leverage. Leverage amplifies everything, the good practices and the bad ones.
The question is not whether to use it. The question is whether you have built the guardrails that let you survive using it.
Organizations without governance infrastructure will ship technical debt at unprecedented speed. Those with quality gates, security validators, and pattern libraries will see multiplicative productivity gains.
Build those first. Then let the agent run.
I paid the tax. I built the machine. And now, the machine builds the software.
And honestly? I am never going back to writing utils.py by hand again.