The phases of building with Agentic Support — from asking questions to fully hosted agents

I didn’t start with autonomous agents — nobody does

When I think back to where my journey in building with agentic AI started… it wasn’t some grand plan. I didn’t wake up one day and say “I’m going to have an AI build my entire infrastructure.” It started much simpler — I was asking questions about my own code. “What does this function do?” or “Why is this CDK construct failing?” And from there, step by step, I moved through what I now think of as the phases of building with agentic support.

I was very resistent in trusting the AI coding assistants. I tried CodeWhisperer (when it was still a thing) and continued with Q Developer (when it was till a thing). I never trusted the models. Reviewed every single line they built.

I believe most builders go through these same phases. And understanding where you are in this journey — and what comes next — can help you get more value out of the tools that are available today.

Phase 1: Asking questions about your code

This is where everyone starts. You have a codebase, you have a question, and you ask an AI assistant. “Explain this function.” “What’s wrong with this query?” “How does this module connect to that one?”

It sounds simple, but this phase is incredibly powerful already. Instead of digging through documentation or searching Stack Overflow for 20 minutes, you get an answer in seconds — tailored to YOUR code. Not some generic example, but an answer that understands your context.

I think many builders underestimate how much time they save here. It’s not about the AI writing code for you yet — it’s about understanding faster. And that compounds over time.

Phase 2: Building small pieces of code

Once you trust the assistant with explanations, you naturally start asking it to write small things. A utility function. A unit test. A type definition. Maybe a regex that would take you 15 minutes to get right.

This is where you start building muscle memory for prompting. You learn how to describe what you want. You learn when the AI gets it right on the first try and when you need to be more specific. It’s a skill — and it develops surprisingly fast.

The key insight here: you’re still in full control. You review every line. You accept or reject. The AI is like a very fast junior developer sitting next to you.

Phase 3: Building entire features with specs and structure

This is the phase where things get really interesting. Instead of asking for small pieces, you start delegating entire features. You describe what you want at a higher level — requirements, acceptance criteria, design constraints — and the agent builds it end to end.

Tools like Kiro’s spec-driven development enable exactly this. You write requirements, the agent proposes a design, breaks it into tasks, and then works through them one by one. You review, provide feedback, and iterate.

I believe this is where most builders are today — or should be heading. It’s a fundamentally different way of working. You shift from writing code to reviewing code and communicating intent. And honestly… it feels natural once you get used to it. You allow more and more power to the coding agent or assistant. You run them locally or you start running them remotely. That’s where your brain starts to explode.

Side note: For me this includes also to get the agents build infrastructure code as for me the code required to provisioning the application is part of it. I do not make a difference between “application code” and “infrastructure code”.

Phase 4: Operations tasks

Now we’re moving into territory that feels genuinely new. The agent doesn’t just help you build — it helps you operate. Investigating incidents, analyzing logs, running diagnostics, creating runbooks, automating operational procedures.

Think about it: how much of your time as a platform engineer goes into repetitive operational tasks? Checking pod statuses, analyzing deployment failures, reviewing metrics after a release. An agent can do this work continuously and surface only the things that need your attention.

I believe this phase is where platform engineering meets agentic AI in the most interesting way. Your agent becomes part of your operations team — not replacing humans, but amplifying them. The AWS DevOps Agent is an example implementation of one of these agents and so is agent0 by dash0.

We see more and more competitors on this landscape of agentic tooling. You’ll need to decide which vendor to trust to give essentially “full access” to your infrastructure. Initially I recommend to give those agents only read-only access. They work best if you give them access both to the code of the infrastructure and the cloud infrastructure.

This will level up your efficiency in operations.

Phase 6: Hosted agents — the always-on builder

And then… the final phase (for now). Hosted agents that run in the cloud, continuously and ideally autonomous. They’re not waiting for you to open an IDE or type a prompt. They’re watching your repositories, your pipelines, your infrastructure — and taking action when needed.

This is where it gets philosophical. You go from “I use an AI tool” to “I have AI teammates.” They run while you sleep. They open PRs while you’re on a walk. They catch issues before you even know they exist. They go through with you through inner loops (taking decisions by themselves) or ask you for help in taking decisions.

I’m sure that in 12 months, having hosted agents as part of your development workflow will be as normal as having a CI/CD pipeline today. It won’t be optional — it will be expected.

The journey is not linear — and that’s fine

One thing I want to be clear about: you don’t have to go through these phases in strict order. And you don’t have to be “done” with one phase before starting the next. I still ask questions about my code every day — even while I have hosted agents running.

The phases overlap. They coexist. But recognizing the progression helps you intentionally push yourself to the next level. Ask yourself: where am I spending most of my time today? And what would it take to move one phase forward?

What’s next

I’m personally deep in phases 4-6 right now. I’m using agents for infrastructure analysis, operational tasks, and I have hosted agents running for several of my projects.

I believe the next big unlock will be multi-agent collaboration — agents that can work together on different aspects of a system, coordinating with each other and with humans. This is alreay partly available in some products - Kiro Web and also Kiro IDE runs multiple agents in parallel.

What’s missing and where we need to get better

We need to be able to integrate agentic assistants in every part of the enterprise SDLC. Most of the agentic tooling is not yet really for enterprise grade adoption and more importantly not yet integrated within enterprise tools. We’ll need to see way more adoption where agents become part of the SDLC process - not loosely connected where the user needs to decide when to trigger which agent.

Coordinating agents will need to help drive product improvements through SDL processes to generate value for our clients. This is the next era and I see a lot of potential for this within the next 12 months.

Wrap up

The journey with agentic AI isn’t a single leap — it’s a progression. From asking questions, to building small pieces, to delegating features, to infrastructure analysis, to operations, and finally to hosted agents that work alongside you continuously. Each phase builds on the trust and skills you developed in the previous one.

The builders who will thrive aren’t the ones who jump straight to the end. They’re the ones who intentionally move through each phase, building confidence and expertise along the way.

Where are you in your agentic journey? I’d love to hear — reach out to me on LinkedIn or through my contact form. And if you’re stuck in one of the early phases and want to level up… just DO it. Start small, iterate, and build your way forward.