For the past month I have been working with one of the new agentic coding tools. I paid for a Cursor subscription out of my own pocket, just to test it properly for a few weeks. Not the autocomplete kind that suggests the next line. The kind that takes a task, reads the codebase, makes a plan, edits many files, runs the tests, and comes back with a result. You give it work, you walk away, you review what it did. It feels less like a tool and more like a junior teammate who types very fast and never gets tired.
One month is not much, but it is enough to have opinions. Here is what I learned, what I delegate now, and what I refuse to delegate, maybe ever.
I should also mention, I started a new job this month, new codebase, and the agent helped me learn it faster than any onboarding doc could. Asking it to explain a module and trace a flow through unfamiliar code turned out to be one of the best uses.
What I delegate happily
The pattern that emerged is simple. I delegate tasks where the definition of done is mechanical and checkable.
Tests are the best example. I write one or two tests myself to set the style, then I tell the agent, cover the rest of this class the same way, include the edge cases for empty input and bad dates. It produces in twenty minutes what would take me half a day. I review every test, and I delete maybe a quarter of them for being noise, but the trade is still massively in my favor.
Migrations and mechanical refactors are the second category. Rename this concept across the codebase. Move these classes to the new module structure. Update every caller of this deprecated method to the new signature. These tasks are tedious for a human and almost perfectly shaped for an agent, because the spec is exact and the compiler plus the test suite will catch most mistakes.
The third category is first drafts of anything well specified. A new endpoint that follows the same pattern as the five existing endpoints. A parser for a documented file format. The key words are well specified. When I can describe done in two or three clear sentences, the agent usually lands close.
What I never delegate
Domain decisions. Never. What should happen when a trade settles late, how to handle a refund across currencies, which states an order can move between. These decisions encode the business, and the business lives in conversations, in context, in the heads of people I talk to. The agent has none of that. It will happily invent a plausible rule, and plausible business rules are how systems quietly do the wrong thing for months.
Architecture is the other one. Where the boundaries go, what depends on what, which parts must be easy to change later. These choices are bets about the future of the product and the team, and they are exactly the kind of judgment I am paid years of scars for. The agent can give me options and write the code once I decide. The deciding stays with me.
My short rule, the agent gets tasks, I keep decisions.
Small safe steps, now for agents
The biggest surprise of the month was how much old wisdom transferred. The discipline of working in small, safe, reversible steps is as old as our craft, and it turns out that advice was secretly written for agent supervision.
When I gave the agent a big task, refactor this whole module, the result was a giant diff that I could not honestly review. I either had to reject it all or trust it blindly, and both options are bad. When I gave it the same work as a chain of small steps, each one green on tests before the next, every diff was reviewable in minutes, and any wrong turn cost me one step instead of one afternoon.
This is just risk management. The agent is fast and a little unreliable, like a brilliant intern. You do not let an intern restructure the codebase in one weekend. You give them small pieces, you check each piece, and the trust budget grows slowly. Same protocol, new teammate.
Was it worth the money
Let me be honest about the economics, because the hype around these tools deserves some honest accounting.
The agent saved me real time this month, my rough guess is 20 to 30 percent on the tasks I gave it. But supervising has its own cost. Writing a good task description takes thought. Reviewing the output takes focus, and reviewing AI code needs more suspicion than reviewing a colleague code, because the agent never says I am not sure about this part. A colleague does, and that one sentence is worth a lot.
The net is clearly positive for me, but it is not free magic. The skill that pays now is decomposition, breaking work into small, well specified, checkable pieces. Which is funny, because that was always the skill that separated senior engineers from the rest. The agents did not change the game. They raised the price of being good at the old game.
One month in, my summary is this. The agent took the typing, and left me the thinking. Honestly, that is the trade I have wanted since I started in this industry. I just did not expect a machine to be the one offering it.
Pax et bonum.