VIDEO COURSE · AGENTS
The AI Coding Workflow That Ships: From Brain Dump to Production Code
A free 7-chapter video course on the principled agentic-engineering workflow. Turn a raw brain dump into a PRD, auto-create JIRA tickets, and ship production code with Claude Code using the Plan-Implement-Validate loop, with copyable commands and prompts at every step.
- Chapters
- 7
- Runtime
- 67 min
- Level
- Intermediate
- Copyable assets
- 19
- Certificate
- Free, exam-verified
- Published
- Jul 5, 2026
- Reviewed
- Jul 5, 2026
✓ Tested by AI Insiders in July 2026 with Claude Code; commands cross-checked against the free companion repository.
What you’ll learn
- Run the three-phase agentic workflow (Planning, the PIV Loop, and System Evolution) on any project, with any coding agent
- Turn an unstructured brain dump into a reviewed PRD with one reusable command
- Auto-create fully contextualized JIRA tickets from a PRD using the Atlassian MCP server
- Prime a fresh coding-agent session with exactly the right codebase context, and research with subagents without flooding it
- Delegate implementation safely using plan artifacts, fresh sessions, and built-in self-validation
- Convert every bug into a permanent upgrade of your rules, commands, and skills
Before you start
- A coding agent. Claude Code (used in the video), Codex, and GitHub Copilot all work
- One place to track work: JIRA, Linear, or GitHub Issues (local markdown works too)
- Basic comfort running slash commands inside your coding agent
- Optional: the free companion repository with every command and skill (linked in Chapter 1)
Course curriculum
- 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. 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. 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.
- How to plan software features with an AI coding agent (before any code) The Phase 1 planning method: brain-dump your ideas, make the agent ask clarifying questions, stay high-level, and build your AI layer of rules and commands. Start feature planning as an unstructured conversation. Brain-dump everything you want to build (speech-to-text makes this fast), then flip the script and have the agent ask you clarifying questions one at a time. Twenty to thirty minutes of this kills the wrong assumptions that cause most bad agent output. Stay at requirements level; implementation detail comes later, per ticket. Then encode what works into a permanent AI layer of global rules, commands, and skills. Anything you have prompted three times becomes reusable. Most bad agent output is not broken code. It is misalignment with what you actually wanted, and removing assumptions up front is your responsibility.Have the agent interview you. 'Ask me clarifying questions one at a time' is the single highest-leverage planning prompt.Layer-one planning stays at requirements level. No file paths, no test plans yet.The rule of three: any prompt you have typed three times becomes a command or skill.
- How to create a PRD with Claude Code from a raw brain dump Live demo: brain-dump a sprint into Claude Code, answer AskUserQuestion prompts, then run /create-prd to generate a structured, reviewable requirements document. In Claude Code, paste your brain dump and let the agent interview you through the AskUserQuestion tool. Accept its recommendations for speed, or correct wrong assumptions the moment they surface. When the conversation feels aligned, run /create-prd with an output path as the argument. It converts the entire conversation into a structured PRD with an executive summary, mission, target users, and in-scope work. Review the document before creating any tickets: the PRD is the source of truth everything downstream inherits. Commands take space-separated arguments like a CLI, so one command serves every project and output location.Encode your team's existing PRD format into the command, so the agent writes documents the way your team already does.Never pipe a fresh PRD straight into ticket creation. Reviewing the artifact is the human-in-the-loop step that makes delegation safe.The finished PRD equals your conversation plus the /create-prd structure. Cole calls it the baby of both.
- How to auto-create JIRA tickets from a PRD with Claude Code and MCP Run /create-stories to split a PRD into JIRA tickets via the Atlassian MCP server: acceptance criteria, dependencies, and technical notes included automatically. With a reviewed PRD, run /create-stories with three arguments: the PRD path, your JIRA project ID, and the epic ID. Claude Code breaks the document into user stories, then uses the Atlassian MCP server to create every ticket, complete with acceptance criteria and technical-note comments it researched from your codebase. The same flow works with the GitHub CLI or the Linear MCP server. Setup is a single .mcp.json file, and Claude can write that file for you. Three arguments drive the whole step: PRD path, JIRA project ID, epic ID. Swap the JIRA calls for the GitHub CLI or Linear MCP and nothing else changes.You never do JIRA admin again. Creating, assigning, and updating tickets is agent work now.Ctrl+O in Claude Code reveals the raw MCP tool calls: your visibility into what the agent is actually doing.The agent does more than create tickets. It researches the codebase and attaches technical implementation notes as comments.
- How to prime Claude Code with codebase context (PIV loop step one) Start every implementation fresh: /prime loads the ticket, codebase patterns, and git history, then subagents research without flooding your context window. Every ticket starts a brand-new Claude Code session. The developer picking up work has no memory of the planning conversation, and that is by design. The /prime command rebuilds exactly the context needed: it pulls the JIRA ticket through the MCP server, studies the codebase and recent git commits, and reports a summary. From there you explore solutions freely, spinning up subagents for research so that a hundred thousand tokens of codebase reading collapses into a few thousand tokens of summary for your main agent. Two planning layers: project-level (the PRD) stays high-level, while ticket-level digs into files, architecture, and docs.Git history is long-term memory. Recent commits teach the agent the patterns your codebase actually follows./prime is a starting point. Tune how much context it loads for your codebase; the command is the lever.Subagents burn 100k tokens on research and hand back a few thousand. That is the point.
- How to turn a plan file into working code with Claude Code (/plan and /implement) Create a plan.md carrying every implementation detail (patterns, files, task order, validation), then execute it in a brand-new session with the /implement command. The /plan command converts your exploration into a single plan.md artifact: summary, locked-in decisions, patterns to follow, the exact files to create or change, task order, and a self-validation strategy covering type-checks, linting, unit tests, and even browser automation. Then comes the critical move. You implement in a brand-new session with /implement path/to/plan.md. The plan carries all the context, the fresh agent brings unbiased eyes, and it writes the code, validates its own work, and hands back to you for code review. The plan artifact contains everything implementation needs, which is exactly why implementation can and should happen in a different session.Have the agent validate as much as possible (tests, linting, type checks) so less needs correcting when control returns to you.Planning sessions accumulate bias. A fresh implementing agent gets clean eyes on the problem.The engineer still reviews production code. Delegating the writing is not delegating the responsibility.
- How to make coding agents improve after every bug (System Evolution) Phase 3: treat every bug as a defect in your AI layer. Run a retroactive session, upgrade rules and commands, and version them like code so the team compounds. When a PIV loop produces a bug, fixing the code is only half the job. Fix the system that allowed it. Run a retroactive session: you let this problem in, so inspect your rules, commands, and skills and propose improvements so it cannot recur. The four things to evolve are your commands, your on-demand context, your global rules, and your plan and PRD templates. Check them into source control and review changes through pull requests. One improved command can save a team dozens of hours, permanently. Coding agents are non-deterministic. The question is not whether mistakes happen but whether each one improves the system.Every bug traces back to context you gave the agent, and context is editable.Version your AI layer like code: source control, pull requests, code review for commands.Two loops. The inner PIV loop ships work; the outer evolution loop makes every future inner loop better.
Frequently asked questions
Do I need Claude Code to follow this AI coding workflow?
No. Cole demos Claude Code with JIRA, but he states plainly that the process is tool-agnostic. Codex, GitHub Copilot, or any capable coding agent works, and JIRA can be swapped for Linear, GitHub Issues, or local markdown files. The only requirements are one coding agent and one place to manage work.
Is this the same thing as vibe coding?
The opposite. Vibe coding hands the wheel to the model. This workflow keeps you in the driver's seat through structured planning and validation. The agent writes the code, but every artifact it produces (PRD, tickets, plan, implementation) passes through human review before it moves forward.
How is this different from BMAD, GitHub Spec Kit, or Claude Flow?
Those frameworks are powerful but opinionated and heavy, which makes them hard to mold onto a team's existing software development lifecycle. This workflow is deliberately minimal: a foundation of a few commands you customize to your own conventions, instead of an off-the-shelf process you must adopt wholesale.
Where do I get the commands and skills used in this course?
Everything sits in Cole's free open-source companion repository at github.com/coleam00/ai-transformation-workshop: the demo app, the global rules, /create-prd, /create-stories, /prime, /plan, /implement, and the agent-browser skill. He invites you to take any of it.
How long does the workflow take on a real project?
Longer than the demo. Cole compresses a four-hour corporate training into one hour and skips review steps on camera that he insists you should not skip. Expect 20 to 30 minutes of clarifying questions during planning, plus real time reviewing PRDs and plans. It still beats writing the documents, tickets, and code yourself by hours.
GET NEW GUIDES
Never miss a guide.
In-depth, fully sourced AI guides — models, agents, tools, funding & policy — sent when they're published. No spam, unsubscribe anytime.
You’re in. New AI Insiders guides will land in your inbox the moment they’re published. No confirmation needed.