Not "AI-assisted." Not "copilot suggestions I edited." I made a rule: for 30 days I don't type application code. The AI does. My job is to describe, review, and approve.
I shipped a real product this way — a small SaaS with auth, Stripe billing, a dashboard, and a public API. It works. It's in production. And along the way I found out exactly where the "AI writes everything now" dream holds up and where it quietly falls apart.
This isn't a hype post and it isn't a doom post. It's a field report.
The rules
To keep myself honest:
- I don't write application logic by hand. I prompt, the AI writes.
- I can read every line, reject it, and ask again — but I can't fix it myself in the editor.
- Config, secrets, and "click the button in the dashboard" steps are mine (the AI can't do those anyway).
- If I get truly stuck for more than an hour, I log it as a "break" and write the code myself.
By the end I had 9 logged breaks. Those breaks are the interesting part.
What worked shockingly well
Let me be fair to the machine first, because a lot of this genuinely surprised me.
Greenfield scaffolding is basically solved. "Set up a Next.js app with Postgres, Drizzle, and auth" — done, correctly, in one shot. The first 40% of the project flew by faster than I've ever built anything.
Boilerplate it never gets wrong. CRUD endpoints, form validation, Zod schemas, a table with sorting and pagination. The stuff I hate writing, produced perfectly, every time, no notes.
It's a phenomenal rubber duck. "Why is this query slow?" got me a better answer than I'd have reasoned to alone — it spotted a missing index and an N+1 in the same breath.
For the first week I genuinely thought I'd write the "developers are obsolete" post. Then week two happened.
What broke — the 9 breaks, honestly
Break 1–3: It can't hold the whole system in its head
Brilliant at the file in front of it, blind to the one three folders over. It wrote a second formatCurrency helper because it didn't know the first existed. Re-implemented my auth check inline instead of the middleware I already had. Introduced a subtly different User type in a new module.
None of these are "bugs" — everything compiled, everything passed. They're architecture drift, and architecture drift is invisible until the day it costs you a week.
The AI optimizes locally. Coherence across a system is still a human job.
Break 4–5: It confidently writes plausible, wrong code
The scariest failures weren't crashes. They were code that looked right and ran fine on the happy path.
The billing webhook it wrote acknowledged Stripe events before persisting them. Flawless in testing. In production, one DB blip = a paying customer locked out, no record, no trail. I only caught it because I've been burned by exactly this before. A junior copying this output would not have caught it. That's the part that keeps me up.
Break 6: Debugging its own code is a hall of mirrors
When something broke that the AI couldn't see, asking it to fix it produced changes, not fixes. It would rewrite the function, swear the bug was gone, and reintroduce it two prompts later. Without dropping into the debugger myself to understand the real state, we'd have spun forever. Biggest time sink of the month.
Break 7–8: Taste, and saying "no, less"
Asked for a settings page, it gave me 14 options nobody wanted. Asked for error handling, it wrapped everything in try/catch and swallowed the errors. The AI's instinct is always to add. Knowing what to leave out — the product-design part of engineering — it has none.
Break 9: The last 10% is still 90% of the work
"Demo works" took a week. "Handles a real user doing something weird at 2am" took the other three. Edge cases, race conditions, the empty state, the error state, the double-click state — the AI does none of it unless you know to ask, and knowing to ask is the job.
The uncomfortable synthesis
AI didn't replace me. It replaced the *tasks I used to give juniors.* The scaffolding, the boilerplate, the first draft — the exact work a junior becomes a senior by doing. So if the AI does all the entry-level work, where does the next senior come from? You can't skip the 10,000 hours; you can only move where they're spent.
The skills that mattered every single day were senior ones: knowing the code was subtly wrong, knowing what not to build, holding the whole system in my head to catch the drift. AI didn't flatten the hierarchy — it made the top more valuable and sawed off the ladder to get there.
What I actually changed
I didn't stop using AI — I use it for 100% of the typing now and always will. I changed the guardrails, and every one maps to a break above:
- The thing that writes the code is never the thing that reviews it. A separate reviewer, prompted to refute the diff, catches the plausible-but-wrong code the author always waves through.
- Nothing merges without a human who can see the blast radius the model can't.
- "It compiles and the tests pass" is the start of review, not the end — the model writes tests that agree with its own wrong mental model.
Author here, skeptic there, human on the merge button — that separation is the whole reason I could hand the typing to a machine and still sleep. It's also exactly how we build xenition: agents that do the work, a different agent that tries to tear it down, and a person who owns the decision.
Would I do it again?
For a prototype? In a heartbeat — I'd never scaffold by hand again. For production? AI for 100% of the typing and 0% of the thinking. The typing was never the hard part. It just felt like it was.
Top comments (0)