Home / Guides & Tutorials / The AI Coding Workflow That Ships: From …

CHAPTER 1 OF 7 · 7 min · 2 COPYABLE ASSETS

What is a principled AI coding workflow? The three phases explained

Why AI coding fails without structure, and the three-phase workflow (Planning, the PIV Loop, System Evolution) that makes coding agents reliable and repeatable.

TL;DW

A principled AI coding workflow has three phases. Planning turns raw ideas into structured, reviewable work. The PIV Loop (Plan, Implement, Validate) repeats for every ticket. System Evolution turns every bug into a permanent improvement of your AI setup. The system is deliberately minimal: a foundation you mold onto your existing process rather than a heavyweight framework you adopt wholesale, and it works with any coding agent and any work tracker.

Watch: FULL Guide to Becoming a Principled Agentic Engineer (Build Anything with AI)

▶ Watch this chapter on YouTube from 0:00

Lesson · 6 parts

This is the polished version of a live workshop Cole Medin ran with Lior Weinstein, and it opens with a thesis worth keeping. People over-engineer AI coding constantly, acting as if real work at scale demands a fancy harness or a fleet of specialized agents. It does not. What you need is a small set of core principles, applied consistently.

The whole course reduces to three phases: ideate with your coding agent, run an iterative loop to build each piece of work, and evolve your agents over time. Cole has covered fragments of this on his channel, but never as one system. Finish all seven chapters and you hold a complete workflow you own end to end, not a borrowed framework you half understand.

The engineer's role is no longer writing the code. It is the higher-leverage work: planning what gets built and validating what the agent produces. That is also why this course applies to product managers almost as much as developers. The first phase, turning ideation into structured work, is PM work done with a coding agent instead of a blank JIRA board.

Cole compresses a four-hour corporate training into this hour, but the core discipline survives. You are not vibe coding. You put yourself in the driver's seat through all the planning and validation you do around the agent. The demo uses Claude Code plus JIRA, and the process stays tool-agnostic: Codex with GitHub or Copilot with Linear work the same way.

The only two requirements

One place to manage work: JIRA, Linear, or GitHub Issues (local markdown also works)
One coding agent: Claude Code, Codex, GitHub Copilot, or similar

Everything demonstrated in this course lives in an open-source repository: the demo application plus Cole's rules, commands, and skills in the .claude folder. He says it outright: steal anything you want. Most of the course is not manual typing. It is invoking these pre-packaged prompts, so keeping the repo open beside the video pays off immediately.

Companion repo with all commands, skills, and rules from this course https://github.com/coleam00/ai-transformation-workshop ↗

Cole names the elephant. Dozens of opinionated open-source frameworks already guide a research, plan, build, validate process, and many contain genuinely good software-engineering ideas. Most are also over-engineered and hard to mold to how your team already works, so adopting them means throwing out your existing software development lifecycle. This workflow is simple on purpose: a foundation you extend with your own planning, QA, and conventions, not a replacement for them.

Study notes

Part 1 of 6 · 0:00 to 1:07

Why this workflow exists

Concept An agentic coding workflow is a repeatable process for directing AI coding assistants: you plan the work, the agent writes the code, you validate the result. Keep that triangle in mind, because every technique in this course strengthens one of its three corners. What it is not: a framework to install, a harness to configure, or a fleet of specialized agents to babysit.

Why it matters The over-engineering warning matters because complexity is where reliability goes to die. Every layer between you and the agent is a layer that can silently misbehave. When your process is three phases you can hold in your head, you can tell where a failure came from. When it is a forty-file framework, you cannot, and debugging the process becomes harder than the work.

Concept The three phases in plain terms. Planning: turn what you want into structured, reviewable work items. PIV Loop: for each item, plan the change, let the agent implement it, validate the result. System Evolution: when something goes wrong, upgrade the rules and commands that allowed it. Learn the names now; the whole course hangs off them.

Do this

Get comfortable. This chapter is orientation; no setup needed yet.
Keep one question in mind: where does your current AI coding process lose reliability?

Part 2 of 6 · 1:07 to 2:11

Three phases and a system you actually own

Why it matters Ownership is the quiet requirement behind reliability. A process you assembled yourself is one you can debug at 2 a.m., bend around a strange project, and teach to a new hire in an afternoon. That is why this course hands you parts instead of a product: assembling them is the learning, and the assembled thing is yours.

Concept Notice the scope claim: the same three phases cover a website, a funnel, an internal tool, or a production platform. That generality works because the phases operate on artifacts (documents, tickets, plans) rather than on any particular stack. If your work can produce a document and a ticket, this process can carry it.

Try it Before moving on, answer one question honestly: which of the three phases does your current AI usage skip? Most people prompt straight into implementation, skipping planning entirely and validating by feel. Naming your gap tells you which chapters will pay you the most, and what to change first on your next real task.

Do this

Memorize the three phase names: Planning, PIV Loop, System Evolution.
Map each phase to your own workflow and note which one you currently skip.

Part 3 of 6 · 2:11 to 2:55

Your new job: plan and validate, not type

Concept Your role in this system has a precise shape: you own decisions, the agent owns execution. Planning is deciding what to build. Validation is deciding whether what got built is right. Everything between those two checkpoints is delegatable typing, and the course treats it that way without apology.

Example A concrete picture of the division of labor: in one sprint, you speak the intent and constraints, the agent drafts the PRD, you correct it, the agent creates the tickets, a fresh agent implements each one, and you review the diff like any pull request. Six handoffs, and every deciding step belongs to you.

Do this

Write down the two activities that stay human: planning and validating.
If you work with PMs, flag this course for them. Phase 1 is their entry point.

Part 4 of 6 · 2:55 to 3:38

Not vibe coding: you stay in the driver's seat

Pitfall Vibe coding is the failure mode this system exists to prevent: prompting an agent loosely and accepting whatever compiles. It feels fast for an afternoon and costs you a week later, because nobody can say what the code was supposed to do. When a step in this course feels like ceremony, it is usually the step preventing exactly that.

Concept Your setup checklist is genuinely two items: a coding agent and one place where work items live. The demo uses Claude Code and JIRA, but the process only assumes the agent can read and write your tracker. GitHub Issues with the gh CLI, or Linear with its MCP server, satisfy that requirement identically.

Do this

Check you have the two requirements: a coding agent and a work tracker.
Pick your combo now (Claude Code plus JIRA in the demo) so you can follow along.

Part 5 of 6 · 3:38 to 4:42

Grab the free companion repository

Concept The companion repository is the course's asset pack: the demo application plus the complete AI layer (global rules, commands, skills) in the .claude folder. Open it now in a second tab. You will meet create-prd, create-stories, prime, plan, and implement one at a time over the next six chapters.

Try it Do not just star the repo. Pick one command file and read it top to bottom; five minutes inside create-prd will demystify the entire system, because you will see that a command is nothing more than a well-written procedure stored as markdown. Nothing in it is beyond a quick edit.

Why it matters Here is why the workflow involves so little typing: everything Cole prompts repeatedly is packaged as a command. That is the habit to import into your own work. Package once, invoke forever, and share the package with your team through source control so the whole group runs the same procedure.

Do this

Open the companion repository from the lesson panel in a new tab.
Skim the .claude folder: rules, commands, and skills you can reuse.
Keep the repo open beside the video for the rest of the course.

Part 6 of 6 · 4:42 to 6:42

Why not BMAD, Spec Kit, or Claude Flow?

Concept The named alternatives (GitHub Spec Kit, BMAD, Claude Flow) all encode some version of research, plan, build, validate. They are not wrong; they are heavy. Each arrives with opinions about your file layout, your ceremonies, and your naming, and those opinions rarely match a team that already ships software.

Why it matters The molding argument settles the build-versus-adopt question. Your team already has a software development lifecycle: review gates, QA habits, a definition of done. A minimal foundation bends around those conventions. A rigid framework asks the team to abandon them, and in practice teams quietly refuse and the tool dies.

Example A test you can run on any framework, this one included: change a single convention, say your acceptance-criteria format, and count the files you must touch. Here the answer is one command file. In heavier frameworks the answer is often unclear, and unclear means unmaintained within a quarter.

Try it Write down the two or three conventions your team would never give up: the review gate, the ticket format, the testing bar. Those are your customization targets for the AI layer you will build in the next chapter. Everything else can start from Cole's defaults and evolve later.

Do this

If you already use a framework like BMAD or Spec Kit, note which parts you actually touch.
Decide what to keep from your current process. You will mold this foundation around it.

Key terms

Agentic coding workflow: A repeatable process for directing AI coding assistants: humans plan and validate, agents implement.
AI layer: The rules, commands, and skills that teach an agent your team's conventions and procedures. Versioned like code.
Vibe coding: Prompting an agent loosely and shipping whatever compiles, with no planning or validation checkpoints.

Key takeaways

The three phases (Planning, PIV Loop, System Evolution) cover everything from idea to production, for new and existing codebases alike.
Your job as an engineer shifts from writing code to the higher-leverage work: planning and validating.
The only hard requirements are one coding agent and one place to manage work.
Off-the-shelf frameworks like BMAD and Spec Kit are hard to mold to your team. A minimal foundation you own is easier to adopt and evolve.

Watch out

This is not vibe coding. The human stays in the driver's seat through planning and validation. Skip the review steps and you lose exactly the reliability this workflow exists to provide.

Check your understanding

What are the three phases of the workflow, and which one does Cole call the most powerful?

Planning (ideation into structured work), the PIV Loop (Plan, Implement, Validate per ticket), and System Evolution. The last one, because every improvement compounds across every future ticket and every teammate.

What makes this different from adopting a framework like BMAD or Spec Kit?

It is a minimal foundation you mold onto your existing process and conventions, instead of an opinionated off-the-shelf system that forces you to replace your software development lifecycle.

01 0:00 Concept Why this workflow exists ▾

02 1:07 Concept Three phases and a system you actually own ▾

03 2:11 Concept Your new job: plan and validate, not type ▾

04 2:55 Concept Not vibe coding: you stay in the driver's seat ▾

05 3:38 Step Grab the free companion repository ▾

06 4:42 Concept Why not BMAD, Spec Kit, or Claude Flow? ▾