01
You know what context matters
Instead of stuffing everything into a prompt, you design how the agent finds the right knowledge at the right moment.
Founding cohort · Enrollment open
Become the engineer your team follows into agentic development.
Learn the durable patterns behind coding agents your team can actually trust: context, verification, and harnesses. Then build a system that takes intent all the way to a verified pull request.
Immediate course access Weekly live office hours 30-day guarantee
Start now
Immediate, ongoing access
8-week cohort
A guided path to completion
Weekly office hours
Expert help when you get stuck
Certificate
Share your achievement
Does this feel familiar?
The buzzwords are annoying. The middleman feeling is worse.
Loop engineeringGraph engineeringRalph loopsMulti-agent orchestrationHarness engineering
Every new term arrives with the same warning: learn this now or get left behind. But the harder question is quieter: when the agent writes the code, are you still the engineer, or just the person reviewing whatever it produces?
“When coding agents first took off, I tried every announcement. The agents were writing more code than ever, and I was spending my days re-prompting them and cleaning up what they missed. I wasn't getting better at building with agents. I was getting better at following announcements.”
More than 1,000 hours later
Rico took every technique apart and found they all solve the same three problems: context, verification, and the harness. Once his agents' work came with proof, his team trusted it, other teams asked how, and he earned a promotion leading the shift instead of chasing it.
What still matters when the tools change
Context
Give the agent what it needs—without flooding it
Verification
Know the work is right before you trust it
Harnesses
Turn good results into a repeatable system
goal → working change → verified PR
Whoever makes agents trustworthy becomes the person the team follows.
See the learning pathThe Proof Loop
Agents should be creative. Verification should be deterministic.
This isn't a prompting trick. It's the mechanism that makes agent work trustworthy, and you build it into your capstone.
- 1Agent does the creative work
The coding agent plans and implements, then claims it is done.
- 2Deterministic checks decide
Lint and end-to-end tests decide whether "done" is actually true.
- 3Failure becomes a prompt
The failure comes back as instructions written for the next agent.
- 4A fresh agent fixes it
A new session starts with clean context and only what it needs.
- 5Hard cap on attempts
The loop stops after a set number of tries, so it can never spin forever.
harness runillustrative example
agent ✅ Implementation complete
lint ✓ passed
e2e ✗ scenario: guest checkout with expired coupon
expected: coupon rejected · got: 10% off applied
→ NEXT AGENT
You are not allowed to apply a discount when the coupon is expired. The rule is in spec §2.3. Fix applyDiscount() in cart/pricing.ts. Do not edit the test.session 2 · fresh context
e2e ✓ all scenarios passed
attempt 2 of 3 · cap: 3
The transformation
From middleman to the engineer your team relies on.
You won't just use agents better. You'll understand what makes them reliable, and that's what lets you bring your team, your codebase, and whatever tools come next along with you.
From reviewing agent output to leading the shift
02
You know when “done” is real
You build verification into the loop so confidence comes from evidence—not from the agent grading its own work.
03
You can hand the workflow to your team
You turn successful experiments into a harness your team can apply across tasks, people, and repositories.
04
You can improve the system
You measure failures, diagnose where intervention happens, and make autonomy more reliable over time.
Vibe coding
- Chase every new term
- Hope the agent got it right
- Review whatever it produces
Agentic engineering
- Understand what’s underneath
- Prove it with evidence
- Lead the team’s system
The curriculum
Learn the whole system, then build one.
A practical progression from agent fundamentals to a production-minded autonomous coding workflow.
MODULE 01
How agents actually work
Models, loops, tools, state, and the limits behind the magic.
MODULE 02
Context engineering
Shape the working set an agent needs to make strong decisions.
MODULE 03
Retrieval & agentic search
Find the right knowledge without flooding the context window.
MODULE 04
Agent capabilities
Design tools and primitives that make useful action possible.
MODULE 05
Evals & verification
Turn desired behavior into checks you can run and trust.
MODULE 06
Goal-driven development
Translate product intent into executable engineering direction.
MODULE 07
SDD + TDD for agents
Use specs and tests as control surfaces—not paperwork.
MODULE 08
Harness engineering
Build the orchestration layer around models, tools, and feedback.
MODULE 09
Agent legibility
Make the codebase easy for agents to navigate, understand, and change safely.
MODULE 10
Environment engineering
Create safe, useful environments where agents can operate.
MODULE 11
Autonomous coding agents
Run longer, headless workflows without losing control.
MODULE 12
Operating autonomous engineering
Measure, debug, and improve the system over time.
Capstone project
Build an autonomous coding system from goal to verified PR.
Apply the full pattern to a real repository: context, tools, evals, the Proof Loop, harness, environment, observability, and the improvement loop.
- A working end-to-end system
- A reusable pattern for future repositories
- Evidence you can show your team or network
You are not doing this alone
When your agent gets stuck, you have someone to ask.
Bring your questions, your repository, and the failures you cannot explain. In weekly live office hours, Rico will help you reason through the problem and get your system moving again.
Learn from someone building this for real
Rico Romero
Senior Tech Lead at Capital One
Rico has taught thousands of engineers inside Capital One and beyond. He led the team behind context-specs, Capital One's first open-source agent harness—a workflow that takes engineering intent through implementation and verification to a pull request.
Mastering, teaching, and applying these systems helped Rico earn a promotion, professional recognition, and opportunities to lead teams through the transition to agentic development.
Capital One is Rico's employer and is not affiliated with or an endorser of this independent course.
Founding offer
Become the engineer who can lead the shift to autonomous development.
Start learning today. Follow the guided cohort for momentum. Get live help whenever the hard parts stop being theoretical.
- Immediate access to the current course
- The next 8-week guided cohort
- Weekly live office hours
- Practical exercises and capstone
- Certificate of Achievement
- Ongoing course updates
Founding cohort price
$399one time
Founding pricing is available for the initial cohort and may increase as the program expands.
30-day satisfaction guarantee
Go through the material. If it is not the right fit, let us know within 30 days for a refund.
Questions
Before you enroll.
When can I start?+
Immediately. You get course access as soon as you enroll, then you can use the next guided cohort and weekly office hours to keep moving.
Who is this for?+
Engineers, tech leads, engineering managers, and technical founders who already use AI coding tools and want a more reliable, production-minded system.
Do I need to be an AI or ML engineer?+
No. The focus is software engineering around coding agents—not training foundation models. You should be comfortable reading code and working in a repository.
What will I finish with?+
A working capstone that takes an engineering goal through an agentic workflow to a verified pull request, plus a reusable pattern you can carry into other repositories.
What happens in office hours?+
Bring the problems blocking your progress. You can ask questions, get feedback, and learn from the real implementation challenges other engineers bring.
Is there a guarantee?+
Yes. If the course is not the right fit, contact us within 30 days of purchase for a refund.