One-to-one tutoring in Claude Code. We work on your own repository and your own tasks, not exercises, and you keep whatever we build.
I'm not here to impress you with AI trivia. I'm here to help you ship work faster, with less friction, and better results.
Who It's For
Whether you're working solo or building team habits, every session focuses on what matters to you.
1:1 sessions
Small group sessions
Session Formats
Both formats are hands-on and run against your own code. Nothing is a worked example.
Your repository, your tasks, at your pace
One convention the whole team follows
What We'll Work On
Not a lecture. Pick what matters and we build it together, on your own work.
Setup, permissions, and the project context file that decides whether output is useful or confident nonsense. This is where most of the value is, and where most people never look.
Work an agent can complete looks different from work you would hand a person. Learn to split a task so it lands, and to recognise the ones it will quietly get wrong.
Agent code is confident, consistent and plausible, which defeats a quick read. Guards that fail open, tests that cannot fail, and the checks that actually catch them.
Turn the tasks you do every week into something you run rather than retype. Reusable context, saved workflows, and knowing which jobs are worth automating at all.
Specs, test plans, documentation, refactor planning and release notes, done with an agent in a real repository rather than in a chat window.
The basics of an API and an MCP server an agent can actually use, for people who want their own systems driven programmatically rather than by hand.
Available Sessions
Structured sessions with clear goals and hands-on exercises. Each session ends with artifacts you can use immediately.
Install it, point it at a repository you actually work in, and get one real task merged before the session ends. Most of the time goes on the project context file, which is what separates useful output from confident nonsense.
Agent-written code fails differently from code you wrote yourself: confident, consistent, and plausible enough to pass a quick read. We go through real output from your own work and build the review habits that catch it.
How Sessions Run
Every session follows the same practical loop. You leave with something you can use.
What do you do every week? What's wasting time? What does "better" look like? We identify 2-3 highest-impact workflows to build first.
We create something real during the session: a document, template, or workflow. Not theory—actual artifacts.
Run it on another example and tighten it. Find the edge cases. Make it reliable.
Save as a template you can use again. Add it to your growing library. Assign simple practice tasks that compound results.
Packages
Pricing depends on session length and group size. Start small, build as needed.
2 sessions
Setup, a project context file, and one real task merged. Good for testing the format.
4 sessions
Enough sessions to build the review habit, not just the setup. Most common choice.
8 sessions
Across several repositories, including making your own tools agent-callable.
Single workshop
Agree one convention so output stops varying by whoever ran it.
3-4 sessions
Convention, review checklist, and office hours. For teams serious about adoption.
Monthly
Keep the convention current as the tooling moves. Continuous improvement.
Deliverables
Artifacts that live in your repository afterwards, not notes about things to try later.
Book a quick call to discuss your goals and find the right format for you.
