Agentic software engineering with senior engineers in charge

The task, agent, checks and review loop

Every change starts as a written task from an engineer. It states the acceptance criteria, the part of the codebase in scope and the boundaries the agent must not cross, for example: leave the auth middleware alone, do not change the schema, add no new dependency. The agent works through the task and comes back with a proposed diff and the results of its checks. A senior engineer then reads the whole diff, not a summary of it, and either merges it or sends it back with comments. Agents never merge their own work. Continuous integration re-runs the type check, linter and tests on every change, so nothing relies on the agent's own report that its checks passed. Agree written decision records, release cadence and any call schedule around the actual scope and review responsibilities. A weekly production release is not implied by the development method.

What engineers never delegate to coding agents, and why

Some decisions are cheap to get right at the start and expensive to repair later, so they stay with a person. Data models come first. A table design shapes every query written after it, and an agent solving the task in front of it can add a nullable column where a separate table was needed. Authentication and authorisation come next, because a missing ownership check on one endpoint can expose another customer's records while every test still passes. Payment paths, from checkout to webhook handling, stay with engineers because a charge applied twice or not at all is a defect customers notice at once. Anything touching personal data, including logging, exports and retention, is designed and reviewed by a person as well. The security review itself is never delegated either. An agent can be asked to look for problems, but an engineer decides whether a change is safe to ship.

How software quality is checked before it reaches production

When agents write the volume, review gates matter more, because more code arrives each day than one engineer would type, and every line of it still has to be read. So the checks run in layers. Static checks come first: the TypeScript compiler, the linter and the unit tests, run by the agent and again in continuous integration. Behaviour comes next, with Playwright end-to-end tests that drive the real interface through the flows a product cannot afford to break, such as sign-up or checkout. Then a senior engineer reads the diff for what tooling misses: how secrets are handled, whether input is validated at the boundary, whether access control is enforced on the server and what risk a new or upgraded dependency brings. The result is code a client can keep: typed, tested and documented, and the client's from the first commit, with no lock-in to our tooling.

What agentic engineering changes about cost and timelines

Coding agents can assist repetitive implementation and checks, but estimate a change against the actual codebase and acceptance criteria. Discovery, data-model decisions and review still require engineering work. Work runs as AI-accelerated development, starting from $2,000 per month, with scope agreed in writing. The method does not establish a universal cost saving, unchanged review effort or a guaranteed weekly release.

Use the method inside a concrete delivery scope

Coding-agent review is a development process, not a separate reason to rebuild a product. Choose the actual workflow and affected application boundaries first, then agree the checks and review needed for the change. Published case scope can inform that discussion without proving the method used on every historical project.

• Scope a full stack product change
• Assess an existing application
• RateItAll: recorded platform relaunch
• Zing Coach: recorded website rebuild
• Dated illustrative city and working-hour examples