Building with Claude Code: Faster Iteration, Faster Drift

I have been rebuilding a personal project called AEGIS into its third version, and on paper this rewrite should have dragged on for weeks. It did not. Claude Code helped me move through it in a fraction of the time I expected.

But the more honest story is not about the speed. It is about what gets harder when the speed goes up.

First, what AEGIS actually is

AEGIS stands for Autonomous Executive Guild Intelligence System. The name is intentionally dramatic. The idea behind it is not.

It is a personal orchestration layer that sits between me and the systems that constantly demand my attention: Gmail, Calendar, GitHub, Sentry, RSS, bookmarks, and a few of my own services. Instead of me checking each of them, AEGIS watches them, classifies what shows up, and decides whether something is worth my time.

When something is worth my time, it does not just notify me. It proposes an action.

A new alert from Sentry arrives. AEGIS investigates it, finds the relevant resource, drafts a fix, and asks me on Telegram whether to proceed. An email lands in the inbox. AEGIS classifies it, decides if it is useless, transactional, or actually requires me, and only then surfaces a card I can approve or reject. A GitHub webhook fires. AEGIS routes it through a flow that knows what kind of repo it came from.

The four agents inside it are styled after anime characters because borrowed personality is much cheaper than inventing one from scratch. Each has its own scope, tone, and Telegram topic. The whole thing runs on FastAPI, Temporal, and a small Postgres schema, with Telegram as the primary interface.

That is the system. v3 is the rewrite that made it actually feel like a system instead of a pile of scripts.

What v3 actually changed

v2 had grown into something I no longer enjoyed maintaining. There were too many tables, too many implicit contracts between services, and too much logic living in n8n workflows that I could not test.

v3 trimmed it down.

Phase 1 wiped the older shape and replaced it with a much smaller model. Phase 2 added the missing plumbing: interaction flows, workflow run tracking, webhook entry points, schedule syncing. Phase 3 finished the cutover by replacing n8n entirely with native flows for Gmail, Calendar, RSS, Raindrop, alerts, and the learning loop.

That is the kind of work that normally drags. Schema rewrites are not glamorous. Cutover work is even less glamorous. With Claude Code in the loop, all of it became approachable in a way it would not have been if I were doing it by hand.

So far, so positive.

The hard part shows up later

The problem is not the first draft.

The problem is drift.

I do not only mean hallucinations or obvious mistakes. I mean the quieter version: the codebase moves in one direction, but small assumptions stay stuck in an older version of reality. A renamed column lives on in two queries that nobody re-ran. A workflow gets registered in one place but not in the activity list. An alert flow fires against a schema that no longer exists.

None of these are catastrophic on their own. They show up as small follow-up fixes after the bigger milestones land. Together, they tell the real story of AI-assisted coding.

You can build faster. You can also drift faster.

That is why I ended up adding more approval gates around autonomous actions instead of fewer. One follow-up was specifically about stopping the system from burning time and money on noisy investigations and PR-like flows unless I genuinely wanted that work to happen. Another swapped out the remote coding path entirely, not because the tool was useless, but because unattended AI-driven code work was creating more noise than the project could absorb.

The lesson sits with me. The more autonomy you give a system, the more deliberate you have to be about its control points.

The trap for perfectionists

If you lean even slightly toward perfectionism, AI coding has a very specific trap.

Normally, improvement loops are expensive enough that you stop. You ship the good version because another pass costs time and energy you would rather spend elsewhere.

With these tools, another pass is always cheap enough to justify.

One more refactor. One more cleanup. One more naming pass. One more architectural tightening. One more rewrite of the same thing in a slightly cleaner shape.

You move through the loop faster, and you can also stay inside it for much longer. The risk is not just bad code. Sometimes the risk is never deciding the code is done.

What has actually helped

A few habits seem to keep the damage in check.

Define the slice before opening the tool. “Phase 2 adds interaction plumbing” is a much better prompt than “improve workflows.”
Keep the human in charge of architecture. Let the tool accelerate implementation, not decide what the system is.
Add approval gates before expensive or high-impact autonomous actions. Investigation, fix generation, and PR creation should not always be fully automatic.
Force a reality check after each slice. Run the tests, boot the path you changed, and look for stale references immediately.
Budget a cleanup pass on purpose. Assume there will be drift, then contain it to a follow-up instead of endless tinkering.
Write down what done means before you start.

The biggest shift for me has been treating AI coding as an acceleration layer, not a replacement for engineering judgment.

Final thought

Building AEGIS v3 with Claude Code has been productive, sometimes surprisingly so. The system I have at the end of it is one I genuinely use every day, which is the only metric I really care about for personal projects.

But the journey has made me more convinced, not less, that the developer has to stay hands on. The tool can help you write faster, refactor faster, and even think through implementation paths faster. What it does not do is remove the need for taste, restraint, verification, and timing. If anything, it makes those things matter more.

So yes, AI-assisted coding can help you move faster.

Just make sure it is moving you toward an end, and not trapping you inside a better-looking loop.

Building with Claude Code: Faster Iteration, Faster Drift was originally published in Hikmah Techstack on Medium, where people are continuing the conversation by highlighting and responding to this story.