A working software prototype
You leave the workshop with a real repo, not a slide deck — a useful workflow built in your stack and ready to extend on Monday.
WORKSHOPS
Vibe Coding for Real
A practical workshop for turning ideas into functioning software with Codex, Claude Code, Pail, and disciplined engineering habits. Start with the fun part, then make it real with TDD, architecture decisions, hardening, and a deploy path your team can repeat.
What you leave with
A real prototype, a real workflow, a real picture of done.
A repeatable AI-assisted workflow
Codex, Claude Code, and Pail together — with the prompt patterns, review loop, and test seams that keep the build honest.
Clarity on demo-to-production
A grounded picture of what it actually takes to turn a fun prototype into something reliable — testing, deploy, ownership, hardening.
Who this is for
Three kinds of builders show up to these.
Non-technical builders
You have an idea, a Notion doc, maybe a Figma. You can write, you can think in systems, and you want to ship a working version without hiring a team yet.
Technical but not AI-native builders
You ship software for a living and you're tired of AI demos. You want a delivery loop with agents that respects tests, types, and the production bar you already hold.
Engineering teams
Your team is adopting AI coding agents and the rollout is uneven. You want a shared playbook — prompts, review habits, deploy story — that engineers, leads, and reviewers can use.
Formats offered
Pick the shape that fits the team.
Three formats. Same delivery loop. Public cohorts ship publicly; private team sessions adapt to your repo, your conventions, your constraints.
2–3 hours · Public cohort or private
Intro workshop
A focused first taste of vibe coding with engineering discipline. We pair on a scoped feature, get green tests, and leave with a clear sense of the loop.
1 day · Public cohort
Full-day intensive
Idea to small working product. We move fast with Codex and Claude Code, then slow down for TDD, architecture decisions, and a deploy path you can keep.
Half-day to full-day · Your engineers, your repo
Private team
Run it on a real codebase your team owns. We adopt your conventions, sharpen the agent loop against them, and leave behind documented patterns.
Sample agenda
What a full day actually looks like.
Anchored on the full-day intensive. Intros compress this shape; private team sessions adapt to the host repo.
See the four blocks
Block 1 — Frame the build
60 min- Scope the prototype in plain language: who, what, why, the smallest useful slice.
- Stand up the repo, the agent runtime (Codex / Claude Code), and a Pail workspace.
- Write the first failing test together — the loop starts with red.
Block 2 — Vibe coding, with handrails
90 min- Drive the agent to a working first cut: prompt patterns, file conventions, what to delegate vs. drive.
- Make it pass the tests we wrote, then add the next test before adding the next feature.
- Refactor for clarity — naming, types, seams — once the green is real.
Block 3 — Make it real
120 min- Architecture call: data boundaries, error paths, the two or three decisions worth slowing down for.
- Deploy story: CI, environments, secrets, the on-call sketch for a thing this size.
- Demo-to-production checklist — what to fix before this leaves your laptop.
Block 4 — Take it home
45 min- Pair on the next feature each attendee will ship on their own.
- Walk through the prompt template, project template, and checklists in their Pail workspace.
- Set a goal for the optional office-hours follow-up.
What's included
The workshop, the tool, and the follow-through.
Every attendee leaves with the same toolkit I use on client engagements — built around Pail, the dev-utility suite we use during the workshop.
A Pail free-year license
Every attendee leaves with a year of Pail — the dev-utility suite we use during the workshop and the daily driver for AI-assisted building.
Project + prompt templates
The same scaffolds I use on real client work: a starter repo, a prompt library, and the conventions that keep an agent loop coherent.
Demo-to-production checklists
Debugging, launch, and demo-to-production checklists — the small lists that catch the issues that always bite right before a release.
Optional office-hours follow-up
A 60-minute follow-up window once attendees have a few weeks of building behind them — review the repo, unstick the loop, plan the next slice.
Consulting-sprint discount
Workshop alumni who later book a Discovery Sprint or Build Sprint get a credit toward the engagement — the workshop seat counts.
Questions
FAQ
Will this be all prompts and no engineering?
No. The prompt work is the entry point. The workshop moves quickly into test seams, data boundaries, review loops, and deploy decisions.
Do we need an existing codebase?
Public cohorts start from a blank repo with a small starter template. Private team sessions work best when we bring one real workflow from your stack.
What should attendees know already?
Comfortable editing code and using Git. The workshop is practical for non-technical builders who can read code, founders who code, and engineers learning agentic delivery.
What leaves with us?
A working repo, a small test suite, notes on the architecture decisions, a deploy path, the prompt + project templates, and a Pail workspace your team can keep.
Tell me what you want to build
Bring the playful build energy, leave with the engineering loop.
Tell me which format fits, the audience segment you're in, your location preference, and what you want to build. I'll follow up with the next available dates.