Developer Edition
AI-augmented workflows for shipping code. Onboarding, debugging, reviewing AI-generated PRs, deploying without breaking prod. Starts with the repo-context profile that all other workflows build on.
What the full pack includes
The Developer pack covers 23 workflows across the full shipping cycle with AI — from setup to maintenance. The first workflow builds the Repo Context Profile and AGENTS.md that every other workflow references.
Operational playbooks (23 workflows)
Setup & ground-truth docs (Repo Context Profile, AGENTS.md, AI coding stack, codebase onboarding) · Planning & design (PRD → sprint tickets, Architect → Builder feature handoff, API design) · Building (vibe-coding from scratch, legacy refactors, safe schema migrations, Figma → component, multi-model planner/coder workflow) · Quality & shipping (debug from logs, tests that catch real bugs, escape agent loops, deploy to real hosting, PR descriptions from diffs, AI-PR review with a 12-point checklist, output verification before merge) · Maintenance (release notes from git log, weekly tech debt audits, incident postmortems, docs from code).
Recurring workflows you wire once and rerun (5)
- 01Repo Context Profile + AGENTS.md baseline — A two-document ground truth that AI reads on every turn — your stack, conventions, constraints, file map, gotchas. Cuts the "AI doesn't know our codebase" problem at the root.
- 02Multi-model coding workflow — Separates planning (one model) from building (another) so each stage uses the right tool. Includes the handoff structure between Architect and Builder.
- 03AI-PR review (12-point checklist) — Structured pass on AI-generated PRs: imports resolve, async boundaries, schema drift, injection points, config permissiveness, rollback plan. Used per PR.
- 04AI output verifier — Checks AI-generated code against the real installed packages — catches hallucinated APIs, drifted signatures, methods that look right but aren't.
- 05Weekly tech debt audit + postmortem flow — A recurring loop: rank tech debt by cost × likelihood weekly, then turn each incident into a postmortem with one structural fix.
Start here — Foundation
Free with email signup (7)
Onboard onto an unfamiliar codebase
You just cloned a repo you've never seen. Maybe it's a new job, an open-source project, or a client's codebase. Instead of spending 2 days reading files randomly, you use AI to build a mental map in 20 minutes.
Write AGENTS.md for your repo
Every time you start a new AI coding session, you re-explain your stack, conventions, and "don't do that" rules. An AGENTS.md file tells the AI once, permanently. This workflow gets you from zero to a working repo instruction file in 8 minutes.
Debug a production issue from logs
Something broke in production. You have error logs, maybe a stack trace, maybe just "users are reporting X." You need to find the root cause fast without randomly trying fixes.
Escape an AI agent loop
Your AI coding agent is stuck. It's trying the same fix over and over, reverting its own changes, or producing increasingly broken output. You've been watching it spin for 10 minutes and it's not converging.
Deploy your first project (from AI builder to real hosting)
You built something with an AI builder (Lovable, Bolt, v0, Cursor, Claude Code) and it works locally or in the builder's preview. Now you want it live on the internet with a real URL — but you've never deployed anything before.
Turn a diff into a PR description that reviewers actually read
You finished the code. Now you stare at the PR description box for 10 minutes writing something nobody reads anyway. Or worse — you write "fix bug" and the reviewer has no context.
Review an AI-generated PR (12-point checklist)
AI-generated PRs look clean, pass CI, and have nice descriptions — but they hide specific failure patterns that traditional code review doesn't catch. This is a 12-point checklist designed for AI-authored code.
Premium workflows (27)
The 27 workflows below are now built into the app as first-class pages. They cover the heavier strategic work and system-building infrastructure, and open with the relevant full-pack access or all-access.
Turn a PRD into sprint tickets
You have a product requirements doc (or a Notion page, or a Slack thread, or a meeting transcript) and need to turn it into well-scoped tickets with acceptance criteria. Instead of spending an hour decomposing it manually, AI does the heavy lifting.
Plan a feature with Architect → Builder handoff
You're about to build something non-trivial (touches multiple files, has tradeoffs, could go wrong). Instead of jumping straight into code and hoping, you use one model to plan and a different session to build — with a structured handoff between them.
Pick your AI coding stack
You're overwhelmed by AI coding tools — Cursor, Claude Code, Copilot, Codex, Cline, Windsurf, Bolt, Lovable, v0 — and you don't know which ones to use, or whether you need one tool or five. This workflow gives you a concrete answer in 10 minutes.
Build a full feature from scratch (vibe coding)
You want to build something with AI — a feature, a page, a tool — but every time you try, you get half-working code, scope creep, or the AI goes off in a direction you didn't want. This workflow gives vibe coding a structure without killing the speed.
Refactor legacy code without breaking anything
You need to refactor messy code — but you're terrified of breaking something because the code is poorly understood, poorly tested, or both. This workflow uses AI to understand the code first, plan the refactor safely, and verify nothing changed.
Write tests that actually catch bugs
AI-generated tests pass but catch nothing. They mock the thing being tested, assert on calls instead of behavior, and use hardcoded values that can never fail. This workflow produces tests that would actually FAIL if the code broke.
Migrate a database schema safely
You need to change your database schema — add a column, rename a table, change a type, add a constraint. One wrong move and you lose data or break production. This workflow makes schema changes safe and reversible.
Convert a Figma design to a component
You have a Figma design (or screenshot of any UI) and need to turn it into a working component. Instead of eyeballing pixels for 90 minutes, you feed the design to AI with the right structure and get 90% there in one shot.
Design an API from requirements
You need to build an API but jumping straight to code produces inconsistent endpoints, missing error handling, and undocumented behavior. This workflow goes from requirements → spec → stubs → docs in one flow.
Build a feature with multi-model workflow
Using one AI model for everything means one set of blind spots. This workflow splits the work across 2-3 models in distinct roles — architect, builder, reviewer — so each model's weaknesses are caught by another model's strengths.
Verify AI output before shipping
AI-generated code looks correct, compiles, and even passes tests — but contains hallucinated APIs, phantom imports, silent behavior changes, and confident-wrong patterns. This is a 5-minute verification pass you run before committing ANY AI-generated code.
Write release notes from git log
You need to write release notes (for users, for a changelog, for Slack, for stakeholders) but staring at a git log of 30 commits is painful. This workflow turns raw commits into user-facing release notes in 8 minutes.
Run a weekly tech debt audit
Tech debt accumulates silently — outdated dependencies, dead code, TODO comments from 6 months ago, test coverage gaps. Instead of discovering it during a crisis, you run a 15-minute AI-assisted audit weekly and keep a prioritized backlog.
Write an incident postmortem
Something broke in production. You fixed it. Now you need to write a postmortem that's useful (not just a formality) — capturing what happened, why, and what prevents it from happening again. AI does the heavy lifting of structuring the narrative.
Generate documentation from code
Your code works but has no documentation — no API docs, no README sections, no architecture overview. Writing docs manually is tedious and they go stale immediately. This workflow generates accurate docs from your actual code, not from memory.
Build, ship & host your own product (the full path)
You can get an AI tool to build *something*, but turning that into a real product — live on the internet, with sign-in, payments, and a host you won't have to flee in six months — is where most people stall. This is the spine: the order to do things in, the decision at each step, and the exact deep workflow, skill, or guide that does the heavy lifting for that step.
Set up Supabase auth + Stripe checkout end to end
You have a working web app and now you need two hard things at once: people sign in, and some of them pay. Done wrong, this leaks other users' data or grants paid access to people who never paid. This is the ordered path that gets sign-in, protected routes, and paid checkout wired correctly the first time.
Set up CI/CD that deploys safely on every push
Your host already redeploys when you push to `main` — which means a typo, a failing test, or a broken type can sail straight to production. This wires a gate in front of that: every push runs lint, typecheck, and tests first, every PR gets its own preview URL, and only a green build is allowed to deploy. Push-to-ship, without shipping a red build.
Stand up production monitoring: Sentry + uptime + alerts
Your app is live and you have no idea when it breaks. Right now the first sign of an outage is an email from a user — or silence while signups quietly fail. This wires the four things a small live app actually needs: error tracking, an external uptime check on the real critical path, log access you've already tested, and exactly one alert that reaches you.
Wire a custom domain, DNS, and transactional email
Your app is live on a `*.vercel.app` (or `*.railway.app`) URL, and any email it sends — signup confirmations, password resets, receipts — either doesn't go out or lands in spam. This wires the real domain, the DNS behind it, and a transactional email setup that actually reaches the inbox.
Keep your hosting + AI bill under control
Your app is live and it works — and then the host invoice and the LLM-API invoice both start creeping, and one bad week of traffic (or one runaway loop) turns into a number you didn't budget for. This sets a hard floor under the damage, shows you which knobs actually move the bill, and gives you a check short enough that you'll actually run it.
Ship a production AI feature on Claude
A Claude-powered feature is easy to demo and hard to ship. The demo works once on a happy-path input; production gets weird inputs, costs that creep, hallucinations users see, and no way to tell when quality drifts. This is the path from "it works in my chat" to a feature that holds up — cost-controlled, grounded, observable, and verified.
Build the Claude API integration (caching, streaming, tools)
The first Claude call you write works, then doesn't hold up. The system prompt gets re-billed on every request, a long generation times out at the SDK's HTTP boundary, structured output comes back as prose you have to regex, and a transient 529 takes down a user action. This is the integration done so it survives real traffic: caching the stable prefix, streaming long output, current model defaults, tool use, and retries that fire on the right errors.
Tune cost + quality with an eval set
You know your LLM feature costs too much, so you reach for the obvious levers — a cheaper model, a shorter prompt, more caching. Each one cuts the bill. But you have no way to tell whether it also quietly broke the answers, so you ship the cut on faith and find out from a user. This builds a small eval set first, then applies the cost levers one at a time and re-scores after each — so every cut is one you can see held quality, not one you hope did.
Add retrieval (RAG) when context isn't enough
Your Claude feature needs to answer from your own data — internal docs, a knowledge base, product specs — and the model doesn't have it. So it either makes things up or says nothing useful. RAG (retrieval-augmented generation) fixes that by fetching the relevant chunks of your data and putting them in the prompt at answer time. This is the full path: decide whether you even need it, chunk and embed your docs, store them in pgvector on Supabase, retrieve and rerank for a query, and build a grounded prompt that cites sources and admits when it doesn't know.
Observability + guardrails for an LLM feature
A Claude-powered feature that ran fine in the demo will fail in ways a normal app doesn't. It won't throw — it'll return a confident wrong answer, drift in quality as inputs shift, or quietly triple its token cost on a bad prompt. None of that shows up in your error tracker, because nothing errored. This wires the two things that catch it: a log of every call (input, output, cost, latency, traced to a user) and a guardrail on the output *before* the user acts on it.
Pre-ship verification for an AI feature
The demo worked. That's the trap. A Claude feature that answers one clean question in your chat will get hit by empty inputs, 50k-token pastes, prompt-injection attempts, off-topic noise, and hostile users — none of which the demo covered. This is the gate between "it works for me" and "it's safe for a stranger." You run the eval set, attack the feature on purpose, confirm the guardrails actually catch what they're supposed to, verify any AI-generated code in the path, and confirm you'll see what it does in production before you ship it.
Get notified about new workflow drops
The library is now fully in the app: free workflows, premium workflows, and pack pages all share the same catalog. We send weekly updates with new workflows, blog posts, and what we shipped. One email Sundays. No spam.