Agent Sprint: The Agentic Development Lifecycle
A self-paced crash course of about 4 hours. Learn one repeatable process for building with coding agents, where the agent does the heavy lifting and you stay in control.
Buying for a team? Reach out for details
Outcomes
What you'll be able to do
One process you can use on any feature, in a codebase you built or one you didn't.
Write a spec and plan that an agent can follow.
Check agent work with tests and real browser checks, not the agent's word.
Review agent code with confidence, and fix what's wrong.
Feed every lesson back into your setup so the next run goes better.
Use the same process on a codebase you didn't write.
Curriculum
What's in the course
Two parts. First you set up your tools and learn how agents actually work. Then you take a real product from an empty folder to production, one stage at a time, and finish by doing it again on a codebase you didn't write.
15 modules · about 4 hours of video · two real projects
Part 1 · Modules 01–05
Foundations
Get set up, and understand what's happening inside the agent before you hand it real work.
01IntroductionThe lifecycle at a glance, and why it's built the way it is.3 lessons+
- Writing code got cheap. Find out what didn't.
- The ten-stage run every feature in this course goes through
- Choosing an agent and a plan that fit how you work
02Set up your machineA local setup built for working alongside an agent.4 lessons+
- The toolkit, and why every tool you install is also a tool your agent can use
- Setting up your editor and terminal so you're reviewing while the agent works
- Installing the Agent Sprint skill pack
- A command-name clash worth knowing about before you start
03Set up your cloudThe cloud services the project runs on, plus a way to see what your agent is really doing.3 lessons+
- A database that branches like your code
- Preview deploys that come with their own data
- Tracing every agent session: what it did, how long it took and what it cost
04Understanding agentsThe mental model that the rest of the course depends on.8 lessons+
- How models are made and measured, and why the benchmark winner isn't always the right pick
- Why agents get worse the longer a session runs, and how to keep them sharp
- What actually drives your bill
- Where an agent's state really lives
- When to hand work to a sub-agent
- What belongs in your project instructions, what belongs in a skill and what belongs in a tool server
- Why agents forget, and what to rely on instead
- The principles behind every decision in this course
05Claude Code crash courseGet fluent in the agent before the sprint starts.5 lessons+
- Driving a session quickly and confidently
- Permission rules you've tested, not just assumed
- Clear, compact or hand off: knowing which to do and when
- The warning signs of an agent going off track
- Equivalent notes for Cursor and Codex
Part 2 · Modules 06–15
The standard run
Ten stages, from empty folder to production. You build a small social post scheduler end to end, then take the same process into a larger codebase you've never seen.
06Set up your projectThe groundwork that makes every later stage faster and safer.4 lessons+
- A setup your whole team gets from a fresh clone
- Writing agent instructions by hand, and why you shouldn't let the agent do it
- A guardrail that stops destructive commands before they run
- Every pull request gets its own URL and its own database
07DiscoverTurn a vague brief into something an agent can build.4 lessons+
- Letting the agent interview you, and knowing when to push back
- Finding the rules the brief implies but never states
- Why one word with two meanings leads to wrong code
- Prototypes built to be thrown away
08SpecDecide what gets built before any code exists.3 lessons+
- When a change needs a spec, and when it doesn't
- The boundaries every spec should set for the agent
- Catching the wrong approach while it's still cheap to fix
09PlanBreak the work into pieces an agent can deliver well.3 lessons+
- Slicing work so every task delivers something complete
- Turning the plan into issues an agent can pick up
- Spotting which tasks can run in parallel
10BuildLet the agent do the heavy lifting, one task at a time.5 lessons+
- The loop every task follows
- Running parallel agents without them colliding
- Stopping halfway and resuming without losing anything
- What to change when the agent gets it wrong (it isn't your tone)
- When it's safe to let the agent run the whole plan on its own
11Agent verificationGet proof that it works, not the agent's word for it.6 lessons+
- What counts as evidence
- How a green test suite can mislead you
- End-to-end checks in a real browser
- Making the change smaller without changing what it does
- A structured review before any human looks at the code
- A pull request a reviewer can trust
12Human verificationThe stage only you can do.5 lessons+
- Reviewing agent-written code without switching your own judgment off
- Matching your review effort to the risk
- Finding what both the tests and the agent missed
- Turning review comments into fix tasks
- The one rule for approving
13ShipFrom approved pull request to production.4 lessons+
- A go/no-go decision from a panel of reviewers
- The document you need before any release goes ahead
- Deploying, checking production and cleaning up afterwards
- Keeping the docs in step with what shipped
14RetrospectiveMake every run better than the last.5 lessons+
- Seeing where the time and money really went
- Turning repeated corrections into permanent fixes
- Checking whether your setup changes the agent's behaviour at all
- A quiz to check you understand what you shipped
- Rolling improvements out to your team
15Brownfield capstoneThe same process on a codebase you didn't write, with a few surprises left in it.5 lessons+
- What the code can't tell the agent, and how to find it
- Documenting a repo that has no documentation
- Deciding how much freedom the agent gets, and where
- Finishing a migration someone else started
- Taking a real backlog issue through all ten stages
Who it's for
Is this for you?
This is for you if
- You're comfortable with git and the terminal
- You work in JavaScript or TypeScript
- You want a professional, repeatable way to work with coding agents
What you need
- A paid plan for any capable coding agent
- Lessons are shown in Claude Code, and the skill pack also works in Cursor and Codex
Opens November 21
What you get
The Agent Sprint opens on November 21. From then, start whenever you like and go at your own pace, with feedback in the community.
Everything in the Agent SprintSelf-paced
- 01
About 4 hours of video
Yours for life. Watch it in order or come back to any stage when you need it.
- 02
The Agent Sprint skill pack
Reuse it on your own projects, in Claude Code, Cursor or Codex.
- 03
One year in the Accelerator community
Post your work, ask questions and see new material.
- 04
20% off the Software Factory cohort
For when you're ready to automate the checking around your agents.
Agent Sprint■ Opens Nov 21
$299USD · once-off
Lifetime access to the videos. One year of community access.
FAQ
Questions you might have
Still deciding? Watch a few free videos on YouTube and see if the teaching style suits you.
youtube.com/robshocksWhich should I start with?+
If you're new to working with coding agents, start with the Agent Sprint. If you already let agents change real code and want to automate the checking, go straight to the cohort.
When can I join?+
The Agent Sprint opens on November 21, 2026. The Software Factory cohort starts on January 1, 2027. Join the waitlist and we'll email you when each one opens.
What do I need to know already?+
For the Agent Sprint, be comfortable with git, the terminal, and JavaScript or TypeScript. For the cohort, you already let coding agents change real code.
Do I need a specific coding agent?+
No. Any capable coding agent with a paid plan will do. That subscription is separate from the course.
Is the Agent Sprint live?+
No. Once it opens on November 21, start whenever you like and go at your own pace. The Software Factory cohort is live: two sessions a week, each run at two times, with recordings afterwards.
Does it work on existing codebases?+
Yes. The Agent Sprint's final project adds a feature to code you didn't write.
Do I need the Agent Sprint before the cohort?+
No. Agent Sprint learners get 20% off the cohort.
What if I miss a session?+
Each cohort session runs twice, and recordings go up afterwards.
Do I have to be on camera?+
No. Camera and speaking are optional.
Do I get a certificate?+
Yes. The Software Factory cohort includes a certificate of completion.
What comes next?+
The Software Factory cohort. Agent Sprint learners get 20% off.
Do I keep access?+
Yes. You keep the course videos for life. Community access lasts a year from purchase.
What discounts are available?+
Agent Sprint learners get 20% off the Software Factory cohort.
How can I pay?+
By card. Teams can pay by invoice.
Can I add company details to the invoice?+
Yes. Once you've bought, you can add VAT and other company details.
What's your refund policy?+
30 days. Email info@switchdimension.com.
Can I gift a license?+
Yes. Buy it with the recipient's email address. The license cannot be transferred to someone else later.
Can I change the email on my purchase?+
Yes. Email info@switchdimension.com. The license stays with that person and cannot be given to someone else.
Can my company pay?+
Yes. Reach out for team pricing and invoicing.
What are the terms?+
None of these are my question+
Email info@switchdimension.com, or send a message.