What AI Agents Actually Changed About How I Build Software
AI agents made writing code cheap. They didn't make building software easy. They just moved the hard part somewhere else.
Derrick Azaglo
· 5 min read
In this note · 4 sections
People keep asking me if AI agents have made me faster. I’ve been using them on real projects for 12 months, and the honest answer is more complicated than yes.
They made writing code much cheaper. That’s real. But the hard part of the job didn’t go away. It moved, and I had to move with it.
Where I actually got faster
Most of my work is in Laravel, and agents shine wherever the work follows a pattern.
- Scaffolding. Migrations, models, form requests, API resources, CRUD endpoints. The boilerplate I’ve typed a hundred times now shows up in seconds.
- Tests. I’m a little embarrassed by how much this helped. Agents are good at listing the sad paths I’d skip when I’m tired: validation failures, unauthorized users, empty states, the record that’s already been deleted.
- Learning new stacks. I’m picking up Go and Flutter/Dart alongside PHP. Reading docs only gets me so far. Having an agent write a working example inside my own project gets me from “I don’t know this” to “I have something running I can break” much faster, and breaking things is how I learn.
- Refactors. Renames, pattern migrations, dependency upgrades across forty files. This kind of work drains me. An agent doesn’t get bored.
- Throwaway prototypes. This was the biggest gain. When a prototype costs an hour instead of a week, I stop getting attached to my first idea. I can try three approaches, throw two away, and feel fine about it.
Where it didn’t help, or made things worse
The most destructive one was a refactor in a production laravel Api. I had an agent move a set of legacy trip models out of App\Models and into their own module. The code was clean, the diff looked right, and nothing errored. But Laravel matches models to their factories using the App\Models namespace. Once the models moved, that link broke in both directions, and an artisan command, make:set-trips-to-delivery, quietly disappeared from artisan list. No crash, no warning. The fix was small: an explicit newFactory() on ten models and a $model property on ten factories. The only reason I knew was that the agent’s own verification run surfaced it and it reported it. If that step hadn’t been part of the task, it would have shipped.
Other times the problem was scope. My setup runs Pint after every code change, which is meant to be a guardrail. But one time the agent ran it across entire directories instead of only the files it had touched. It reformatted code nobody had asked it to change and scrambled the import order in about 113 files. Working out which changes were real meant comparing everything against a clean checkout. The guardrail did more damage than the change it was guarding.
And sometimes it was just confidently wrong. While redesigning this portfolio, an agent told me the site had “no keyboard focus indicator anywhere.” That sounded like a real accessibility bug, and I believed it. It wasn’t true: buttons and links already had the browser’s default outline. What was missing was a designed focus style, which is a much smaller problem. Then, when it tested its own fix, it reported the new focus ring wasn’t working. That was wrong too. Its test had selected a sidebar link instead of the button. Both times, the agent sounded exactly as sure as it did when it was right.
What I changed afterwards: verification is part of every task, not something I do later. The agent runs the tests and checks the real output before it tells me it’s done. Automated tools only run on files that actually changed. And when an agent tells me something about my own system, I treat it as a claim to check, not an answer.
What I took from it: agent code fails quietly. It almost never crashes in an obvious way. It looks right, it runs, and it passes the happy path. That’s what makes it dangerous. A junior developer who’s unsure will usually ask. An agent never sounds unsure.
So now I review hardest where quiet failures cost the most:
- Permissions. Who can see this, who can change it.
- Money. Rounding, currency, anything that charges a card twice.
- Concurrency. Two requests at once, retries, queues.
- Data changes. Migrations, bulk updates, deletes.
There’s also a speed illusion, and I fell for it. In 2025, METR ran a randomized study with 16 experienced open-source developers working on their own repositories. With AI tools they were about 19% slower. They also believed they had been about 20% faster.
That gap stuck with me more than the number did. The tools have improved a lot since early 2025, so I don’t read it as “AI makes you slower.” I read it as: how fast it feels is not how fast it is. Now I pay attention to what actually ships and holds up, not how quickly code appears on screen.
How I work with agents now
This took a while to figure out, and I’m still adjusting it.
- I write the spec first. Behavior, constraints, acceptance criteria. If I can’t explain what I want in plain words, the agent can’t build it, and honestly I wasn’t ready to build it either. Writing the spec is where most of my thinking happens now.
- I keep tasks small. “Add rate limiting to this endpoint, with tests” works. “Build the billing module” gives me two thousand lines I don’t trust.
- Tests are the referee. If the agent can run the suite, it can check its own work, and so can I.
- I own the architecture. Boundaries, the data model, naming, conventions. Those are my decisions. The agent works inside them. When I let it decide structure, I end up with a codebase that doesn’t feel like mine.
- I review its code like a junior’s pull request. Carefully, and assuming it’s well-meant. One rule I don’t break: I never merge code I can’t explain. If I can’t walk a teammate through it, it doesn’t ship.
What I actually believe now
Typing was never the real bottleneck. It just looked like one because it was the part we could see.
Now that code is cheap, the scarce skills are the ones that were always underneath: deciding what’s worth building, breaking it into pieces you can verify, and noticing when something that looks right is wrong.
That last one is why I’m spending as much time on fundamentals as on tools. You can’t review code you don’t understand, and you can’t catch a quiet failure in a system you couldn’t have built yourself. The agents made me faster at the parts I already knew. They made understanding the rest more important, not less.
- AI
- Laravel
- Engineering