Coding agents speed you up when you review every change
A coding agent brings speed when the developer designs the solution, directs the agent, and reviews every change before testing.
A coding agent brings speed when the developer designs the solution, directs the agent, and reviews every change before testing. Without that, it's rework.
I use coding agents, with Claude Code, across my whole workflow as a full stack and mobile developer.
My role is to design the solution, direct the agent, review and validate every change, and ensure quality before anything moves on to testing.
The goal is faster delivery without giving up security and maintainability.
Speed without that role is an illusion. The agent writes code fast, but it doesn't know on its own what the system needs or what must not break.
In this piece, I show how that role works on a real payments project, and why it isn't optional.
This isn't a piece against the tool. The point is a different one: who decides what the agent does, and who answers for what it delivers.
A retail checkout with a new card
In 2026, I work as a full stack developer on a retail company's e-commerce app, on a new credit card at checkout.
On the back end, the BFF in Java and Spring Boot exposes the card as a payment method, identifies the customer, and simulates installments.
The simulation covers two plans, billed on the card statement or on a payment booklet, with and without interest.
The BFF handles errors from upstream services and has unit tests in JUnit and Mockito.
In the React Native app, with TypeScript and Redux-Saga, I built the checkout journey: card display, identification, simulation, and installment choice.
The journey also asks for the CVV and shows interest and total in the order details. It is released behind a feature flag in Firebase Remote Config.
This is code that handles the customer's money. A wrong interest rate or total isn't a visual detail: it's a wrong charge.
In this kind of journey, haste without review costs more than it saves.
Where the agent comes in
On this project, I use Claude Code and the Figma MCP every day. Every delivery goes through review and validation before testing.
The agent writes fast. What it doesn't know on its own is which solution fits that system, with those installment rules and those services.
That is why the design comes first: deciding where the rule lives, in the BFF or in the app, and what contract the two will follow.
With the design ready, directing the agent gets simple. The task becomes small, with a start, an end, and a test that says whether it worked.
The Figma MCP brings the designed screen closer to the code. Even so, the review checks whether the result followed the design system.
A vague task produces vague code. The clearer the request to the agent, the less time goes into undoing what it made up.
The agent speeds up the writing. The person who guarantees the code is right is still the one who reviews it.
Review every change before testing
Not all of the work on this project was new screens. I fixed a re-render loop in the checkout and an inconsistent state when returning from the payment screen.
I also integrated the React Native card management library, maintained by another team, with the app as the host.
The integration covered a theme and session contract, design system alignment, native Android and iOS setup, and a navigation fix in biometrics.
Problems like these show up in careful reading, not in speed. The agent makes the change, but its effect on app state needs someone who sees the whole.
Reviewing before testing also helps the team that tests. Testing then confirms behavior instead of hunting bugs that reading the code would have caught.
If you plan to use a coding agent on your product, decide first who designs the solution and who reviews it. Speed shows up once those roles are clear.