From AI-Assisted Coding to Agent-Driven Development - This Is The Way

If you are like me, you are tired of seeing “AI” and “Agent” plastered across every corner of the internet. My LinkedIn and YouTube feeds are drowning in it. Yet here I am, writing about how I went from skeptic to convert after adopting an agent-driven software development workflow.

I am not one to jump on hype trains. I tend to stand back when everyone rushes towards the next shiny thing. That means I sometimes miss the initial gold rush, but I look for lasting value before committing. So while the crowd kept shouting “Agents! Agents!”, I was asking a different question: What tangible thing have you actually built with agents? And while I watched from the sidelines, I noticed something - the people doing genuinely impressive work with agents weren’t the ones shouting about it on social media.

The Beginning

My AI journey started about two years ago. At a previous job, we were tasked with building a front-end interaction powered by Large Language Models that adapted the user experience based on context. It was impressive and innovative for us.

A colleague on the same team was exploring Cursor and spoke highly of it. I was skeptical. Would I just end up spending all my time reviewing AI-generated code? Pull requests within a team are already taxing to review, let alone keeping up with the volume an AI can produce.

Then JetBrains introduced Junie to their IDE lineup, including my go-to, PyCharm. That is when things clicked. I could get tests written, tighten up code, and handle refactoring with real efficiency. Over time, I started playing the role of the Architect and wrote about it here. I also embraced Lovable.dev, which solved my long-standing struggle with quickly prototyping frontends in React. I combined both tools: AI-assisted backend development with Junie, and rapid frontend prototyping with Lovable consuming the backend API.

Like the phrase “Turtles all the way down”, it was now “AI all the way through”.

Enter Agent-Based Workflow

After a few months using Junie for the backend and Lovable for the frontend of a side project, I had made solid progress. But there was a limitation: I could only focus on one area at a time. Lovable had no awareness of the backend code beyond the published API contract. Wouldn’t it be powerful to have a single AI see and work across both frontend and backend from the same repository?

Around this time, I kept hearing about Google’s Antigravity and was listening to podcasts about agent workflows, including stories of people running lean businesses powered by agents. So I took the plunge.

The onboarding experience blew me away. I started a conversation, brainstormed an idea, and eventually the agent and I reached agreement on what needed to be built. When I gave it the go-ahead, it opened my browser, navigated to a site, clicked around, and gathered the information it needed to complete the task. That was the “wow” moment.

And like everything on the internet, once you peek behind the curtain, the algorithm starts pushing related content your way. I quickly discovered several frameworks and approaches for agent-based software development:

  1. BMAD Method - github.com/bmad-code-org/BMAD-METHOD
  2. GitHub Spec Kit - github.com/github/spec-kit
  3. Various conference talks and community discussions

The Agentic Experiment

While exploring Antigravity, I scoped out an idea requiring four components: a Backend API, an Admin Dashboard, a Client Portal, and a Mobile application.

During the planning phase, I described each component’s purpose, the different actors who would access them, and how each depended on the backend. It was fun watching the agent absorb the idea and run with it.

Then something unexpected happened: I became the bottleneck. I had to slow the agent down because I wanted to focus on one thing at a time, but it wanted to build everything at once. That gave me a key insight - agentic workflows do not have to follow the same pace as human development.

Slowing it down was really me trying to keep up and verify it was building the right thing. If I let it run unchecked, I could have had everything built end-to-end in 30 minutes, but reviewing that volume of output would be overwhelming. That experience pushed me to explore methodologies that would let me hand the AI a spec and trust the outcome.

Practical Application

With my new agentic super-powers, I needed to build a Discord bot for my side project - linking Discord to the backend API so users could interact with the service directly from Discord. I had never built a Discord bot before, so there was some reading to be done. I went through part of the documentation and watched a tutorial, then decided to build the bot in Go for its memory and system utilization benefits.

I started with GitHub’s Spec Kit, guided by Den Delimarsky’s walkthrough, which is a solid introduction to the approach.

After going through specification, clarification, planning, and implementation, I had the bot ready in under an hour. Since the bot needed to communicate with the backend (and the backend needed to notify the bot of certain events), I had the agent generate a prompt describing how the integration should work. I passed that prompt to my IDE’s AI assistant.

An agent here, an agent there, and I came out the other end with a fully integrated backend-to-Discord-server pipeline in under an hour. The only thing that stopped me was running out of tokens and having to wait three hours for a reset.

My Verdict

This is how we will be building software for some time to come.

It would typically take me weeks to chip away at a side project feature because I can realistically dedicate about one hour in the evenings to coding. But with agentic workflows, I was compressing days of coding effort into minutes - at the cost of tokens.

AI is an enabler, but you still need to understand how systems are built, what architectural patterns exist, and how to make sound design decisions. It would be foolish to ignore these fundamentals and blindly rely on AI. You have to be the architect. You have to get good at describing what you want.

This whole experience took me back to university, where we learned the software development lifecycle: requirements gathering, feasibility studies, design, implementation, operations, and handover. The process has not changed. The workforce has.

Have you experimented with agentic development workflows? I would love to hear what tools and approaches are working for you. Drop a comment or reach out - let’s compare notes.