AI agents in the development workflow

Moved to using agents like Claude full-time in my real development process. In one month, single-handedly, I closed out the backlog on a legacy project that had been sitting unresolved for 2 years, endlessly postponed due to lack of resources and low priority. On 2 other projects I ran agent-driven refactors: the codebase shed its junk (unused leftovers), heavy queries got noticeably faster, and build times went down. And on top of that I kicked off a completely new application, set up all the environments and plumbing, and drove it to a fully functioning first MVP feature.

What it looks like in practice:

• Task decomposition is partially delegated to the agent — I state the goal and constraints, the agent proposes steps, I correct course
• Routine goes to the agent — project-wide refactorings, boilerplate generation, navigating unfamiliar chunks of code, writing tests from an example.
• Project rules in CLAUDE.md — I pin down agreements and hard constraints in the repository so the agent works within the decisions already made
• Memory and context — hooking up LSP, design and architecture skills, convention skills, regular reports and a strict git-based development pipeline.

What has changed in my work:

• more time goes into framing tasks and reviewing, less into mechanically typing code
• the barrier to entering a new repository/stack is noticeably lower — the agent handles the reconnaissance
• the value of clean architecture and clear naming is felt more strongly than ever: it's easier for both the human and the agent

In adopt — I recommend it as a standard tool in my practice, provided the developer knows how to frame tasks and critically check the results. Let me stress: checking the model's work is mandatory! It's capable of making mistakes out of sheer carelessness!

PS: noticed one slightly scary fact — compared to working as a team lead, essentially nothing has changed. One to one, and that's no exaggeration. I realized that the best vibe coders are team leads. Which led to the reverse epiphany: apparently, the moment I became a team lead, I became a vibe coder — and I've been one for years. It's just that before, the intelligence at my disposal was natural, and now it's artificial.

Trying out Claude on active projects.

AI agents for development have clearly leveled up. Now there are rules and skills, and you no longer have to remind the agent in every prompt how to work with your project. I've tested claude both on an already active project and on a couple of completely fresh setups.

It works really well. There's a whole set of tools for saving tokens and a convenient limits system. Pluses spotted right away:

• brilliantly handles the routine of debugging setups, configurations, installs, version mismatches. Honestly, I've never bootstrapped projects on a stack that's new to me this fast.
• knows how to debug, especially if you give it a console, docker and tests.
• even with a small context window it manages to read all the important nuances of a project — if, after exploring the codebase, you move them into skills and rules, it sticks to the required style with impressive precision

There are minuses too:

• layout work still comes out with rough edges, and I have to file them down myself. Still, it handles most of the routine, and if you give it a well-made mockup in figma and set up a tailwind base in the project, for example, the results come out clean.
• if you just hand it code-writing tasks it can make mistakes around coupling or the language version in use. But these fade away if you give it access to the target language's LSP and let it set up a feedback loop for itself (builds, tests, runnable environments). Given feedback, the agent fixes its own mistakes
• debugging itself can burn a lot of tokens; if you're on a budget, you need to nudge the agent toward the solution paths
• conceptually it's bad at planning ahead unless you ask it to. As a result, in new task sessions it starts fixing and rewriting what it wrote in previous ones, which again leads to token overruns. If you plan the architecture and the concept upfront and write them down in documents and skills, this can be neutralized.

Verdict

The tool has matured. It genuinely helps you get so much more done that it feels like one person can now do in a week what an entire team used to do in two weeks, or even a month.

Essentially, just as CNC machines came to materials processing, AI agents have come to programming — and they're here to stay.

Trying out Cursor on active projects, though in limited doses.

Pluses so far

• Can actually write working code
• Can check itself and even run tests
• Great at writing unit tests, especially if you feed it specs or even a set of user stories.

Minuses so far

• You constantly have to repeat yourself and rein in the context so tokens don't burn away
• The agent plays fast and loose with styles, conventions and rules — again, you have to keep reminding it about DI, the stack, and the ready-made libs that already exist in the project.
• If it hasn't solved the task within 2 prompts, you're better off finishing or redoing it yourself: watching it fix its own mistakes eats a huge amount of tokens and time, and all the benefit of using it evaporates and goes negative.
• Can't do layout work at all, sadly. It clearly lacks the tools to actually see the result.

Verdict

For now, unfortunately, it feels more like a toy. It can already write a simple app solo, but maintaining an existing project with it, or building anything bigger than a single layer — that's hell, and an expensive one.

Discovered Cursor. It's an IDE with an interface for talking to an AI model — and for letting the AI model interact with the workspace open in the IDE. In other words, an AI agent in the shape of a VS Code-based IDE. Looks promising.

Chat GPT 3.5 is out. I couldn't resist experimenting with code generation. Ran it through a few tasks.

Pluses discovered:

• Give it a method or even a class, and it can put together a decent unit test for it.
• You can hand it a spec description of an entity with lots of fields and it will fully formalize it from the description: pick data types; invent names, say, in camelCase; write it out as a table or as a class in the programming language of your choice.
• Gives good hints on where to dig when investigating problems or incidents. Potentially a straight-up StackOverflow replacement.

Minuses discovered:

• Responses get cut off, but apparently on the BFF side, because if you ask the model to repeat its previous (truncated) message starting from a certain line, you get the missing part. Annoying, but livable.
• It writes complex classes with logic poorly. Produces some kind of patchwork quilt. But individual methods come out decently — you can quite happily offload some routine composing to it, just nudging it a bit and pasting the result in.
• It understands powershell badly. Almost everything I asked it to compose was non-functional. Meanwhile the same thing in C# comes out fine, and even if you ask it to first write it in C# and then convert to powershell, that works well too. But ask it to implement in powershell from the start and it writes incoherent nonsense.

Verdict:

On the whole, usable for routine documentation writing, generating unit tests, and doing research. For junior colleagues, especially those who don't navigate code well, I would strongly advise against using it for now.