From AI-Assisted Coding to Agentic Software Development

Take a small development ticket. A developer asks AI to read the requirements, prepare a plan, review that plan, build it, write the tests, open the pull request, review the code, fix the issues and check the automated results. In our own experience, that can mean 10 to 15 prompts for one small ticket, with the developer reading each response, deciding what happens next and waiting in between.

The tools made every step better, but the developer was still coordinating the work, carrying it from one stage to the next. That’s where AI-assisted coding starts to reach its limits, and it’s why we think the real shift isn’t AI writing code faster. It’s AI agents coordinating the process around the code.

How Our Development Process Evolved

At Studio Graphene, our journey towards agentic development has involved four stages, each addressing a limitation of the previous approach.

We started with chatbots. Developers used general-purpose AI assistants outside the codebase, copying in code, errors and ticket text and pasting answers back. The next stage brought AI into the editor, supported by coding rules, shared guides and automated quality checks. AI had more context about our code, but still lacked access to the wider project information.

We then connected AI to the systems where that information lives, including tickets, specifications, error logs and code repositories. Reusable playbooks also helped standardise repetitive tasks. Each step became better informed, but developers were still responsible for prompting and coordinating the process.

The fourth stage changes that relationship. Instead of developers directing each activity individually, agents can coordinate the work through a connected development workflow.

What Agentic Development Changes

In an agentic workflow, agents coordinate and carry out development stages within a process designed and overseen by engineers. A single command can initiate work across multiple tickets, with agents gathering requirements, planning implementation, writing code, testing and preparing changes for review.

One particularly interesting part of our approach is how implementation plans are developed. Three planning agents independently consider different approaches, focusing on safety, simplicity and consistency with the existing codebase. Another agent evaluates those proposals and selects or combines them into a recommended plan. An engineer then reviews and approves that plan before implementation begins.

Once approved, agents build the changes, run automated checks and review the results. Problems can be corrected through feedback loops, with draft pull requests prepared for engineers to review. Individual tickets use separate development environments, allowing independent work to progress in parallel while managing dependencies.

Human oversight remains central throughout. Engineers approve the plan before development and retain responsibility for reviewing and approving changes before they’re merged. Automated checks and independent reviews happen consistently, but accountability for the work remains with the team.

This Isn’t About More Agents Writing More Code

It would be easy to read this as a story about automation, and that would miss what matters. Giving work to more agents doesn’t automatically make it better. The opportunity is to remove waiting, hand-offs and manual coordination while making the development process more consistent.

It also raises the stakes on something we’ve written about before. Agents depend on the quality of the information they’re given. A vague ticket, missing specification or incorrect assumption doesn’t get fixed by automation. It can get built, quickly and with confidence. As we explored in What Happens When AI Can Build the Digital Product?, making software easier to build doesn’t remove the need to decide what should be built.

There’s also a wider coordination challenge. As we discussed in AI Is Making Everyone More Productive. Who Is Coordinating All the Work?, individual productivity doesn’t automatically translate into better team performance. Agentic development is one way we’re addressing that challenge within software delivery.

What We’re Seeing So Far

At Studio Graphene, we’ve developed and tested this workflow on real development tickets, including changes spanning frontend and backend systems. Based on measurements from our own tickets, we’ve seen around three to five times less hands-on developer time, as agents manage activities that previously required repeated prompts and manual coordination.

We’ve also tested how multiple tickets can progress independently, with automated checks and reviews applied consistently. These are encouraging findings, although reduced hands-on time doesn’t necessarily translate into an equivalent reduction in overall delivery time. That’s something we’ll examine more closely as we continue refining the approach.

This is how we want to build, and it reflects our wider approach to AI-native product development, where the process around the technology matters as much as the technology itself.

The next stage of AI-driven software development won’t just be about writing code faster. It will be about designing better ways to build it.