I've spent around five hundred hours in Claude Code. This is the workflow I've ended up with, and the small set of commands at the centre of it.
It's how I work. Take what's useful, skip what isn't.
Plus a free PDF at the end with all the commands I came across along the way.
Most of these commands only make sense in context. Here's the actual workflow I run when I sit down to build something.
It's five steps, in order. The first time through it feels like overkill for anything smaller than a full feature. By the third or fourth project, skipping a step feels reckless, because the steps you skip are the ones that quietly cost you a day later. After the workflow there's one more section about how I use loops and schedules to handle the work that repeats.
Step 1. Brainstorm before you build
/superpowers:brainstorming
I never start with code. The first move is always a real conversation about what we're actually making, why, what the edges are, and what could go wrong. The brainstorming skill asks the questions I would otherwise skip in my hurry to ship, the ones that surface the wrong assumption on day one instead of day five. It forces that exploration before a single line gets written.
Step 2. Turn it into a plan (and pick the skills you'll use)
/superpowers:writing-plans · /skills
Once the direction is clear, I generate a detailed implementation plan. Every step, every file, every dependency, in order. The plan also acts as a checklist I can review before execution, which is the last cheap moment to catch a missing piece.
This is also where I decide which skills the work will lean on. Need copy somewhere? Note that the copywriting skill goes there. Hairy bug expected? Systematic-debugging. /skills shows everything available in the session, and picking them at plan-time means the agents in the next step know which expert workflow to reach for. No improvising in the middle of the work, no scope drift.
Step 3. Dispatch parallel agents
Agent tool · /superpowers:dispatching-parallel-agents
Independent pieces of the plan go to subagents running in the background. While one builds the homepage, another writes the copy, another tweaks the schema. The trick is splitting the plan into truly independent chunks so the agents don't fight over the same files, which the planning step makes easy. Multiple workstreams happen at once instead of me babysitting each in turn.
Step 4. Monitor what's running
FleetView · agent view
A live view of every running agent: what task they're on, how far they've come, what they produced. If one is drifting off track, I can step in before it burns through context on the wrong path. Honestly I don't open it on every project, but on bigger builds with three or four agents running it's the difference between confident parallelism and just hoping things turn out. No black box, no surprises when one returns.
Step 5. Verify before calling it done
/superpowers:verification-before-completion · /ultrareview
Before anything ships, I make Claude prove it works. The model will happily declare victory on work that hasn't actually been tested, so the verification step is non-negotiable. These two commands do different jobs:
- /superpowers:verification-before-completion is a discipline. It forces Claude to actually run the tests, open the page, and check the diff against the plan before saying "done". Think of it as a checklist Claude has to tick before claiming success.
- /ultrareview is a review. It spins up multiple reviewer agents that read your branch and look for issues you and Claude both missed: bugs, security holes, sloppy patterns. Heavier, slower, worth it on anything client-facing.
I run verification on every build, and add /ultrareview for anything that goes to a client or to production. The first catches "did I actually do it", the second catches "did I do it well".
// efficiency boost
Loops and schedules for the work that repeats
/loop · /schedule
This one sits outside the build workflow, but it's where a lot of compounding efficiency comes from. Most weeks I have one-off projects, but I also have a stack of small jobs that should just happen on their own.
/loop runs a prompt on a recurring interval, useful for checks, polls, or babysitting long-running tasks. /schedule creates cron-style agents that fire at fixed times. Concrete examples from my own setup:
- A scheduled agent that checks my inbox twice a day and flags anything client-related
- A weekly job that scans every site I manage for broken links, security warnings, and SSL issues
- A scheduled agent that drafts my daily check-in every morning so I start the day with structure
None of these need to be in the workflow, they just run quietly. The compound effect over a month is enormous, because none of this work eats into the time I'd otherwise spend building.
// free download
The full Claude Code commands guide.
All 50+ commands, organized into 10 categories. Free PDF, no email required. Bookmark it, share it, print it, whatever works.
Download the guide (PDF, 13 pages)A note before you go
Most of the value in Claude Code is not in any single command. It is in stitching them together: memory plus loop plus a couple of agents, running quietly in the background while you do the work only you can do.
If you are a small team trying to figure out how Claude Code, or AI agents in general, fit into your work, that is exactly what I do at Azadev. I help businesses turn manual processes into something that mostly runs itself. Get in touch and I will take a look at where you are.
// keep reading