My Claude Code Workflow, Mid-2026
Sharing the Claude Code workflow I’m currently using after multiple iterations. With the current trend, I know the way we work keeps changing every few weeks, and there are several new things emerging.
Early 2026 I had built around 17 agents in Claude code: a PM, frontend lead, designer, QA, GTM, and others, with one project-manager agent orchestrating them by tagging and maintaining a task board in Markdown. It was working, but maintaining the agents became one of the tasks alongside my other work. Open-source skills and plugins had moved faster and well maintained, so I switched from the sub-agent set up.
The principle that makes the current setup work is that every decision, every plan, and every completed item is dropped into a structured docs folder as a Markdown file. Skills and agents downstream pick them up automatically without me having to re-explain anything.
Spec phase
For any feature to be built, I currently spend more time on specs and planning before diving into the code. The spec phase skills are from Garry Tan’s gstack
/office-hours for the initial spec. It pushes back on premises and stops me from implementing unnecessary stuff by making me rethink. Two modes, builder for side projects, startup for real product work.
/plan-ceo-review for scope expansion. Brings in easy wins and expands the spec where it makes sense.
/plan-eng-review to check engineering feasibility on what came out of the previous step.
/plan-design-review goes through the spec with seven passes. interaction states, responsiveness, a11y, unresolved decisions. Rates each 0–10 and fixes the plan inline.
Once these skills have run, I do a second opinion pass on the spec. Either a new Claude subagent or /codex (OpenAI’s Codex CLI). Catches issues and mistakes the first pass missed. Different model, different blind spots, adversarial by design.
/design-consultation only for new projects. Builds a complete design system from scratch and writes design.md
Design exploration
Before going to Claude Code I usually pull inspiration from a few AI design tools. Lovable, Replit, bolt.new, and Google Stitch each generate different takes on the same spec, and seeing 4–5 variants across tools gives me a sense of the design space before committing to a direction. None of these end up in the codebase. They’re reference points.
For specific components I’m unsure about, I check Mobbin and Dribbble for existing patterns. There’s also the option of connecting Figma or Pencil directly to Claude. I haven’t explored that much yet.
/design-shotgun generates three variants and opens a comparison board in Chrome. The advantage over the external tools is context. Shotgun already knows my design.md, so the variants come back aligned with existing tokens, components, and voice.
When the design direction itself is still unclear, I sometimes use /superpowers:brainstorm in Claude’s plan mode. It’s more conversational and helps me think through what I want before jumping to variants.
Planning and Implementation
For Planning and Building, most of the skills I use are from superpowers. I discovered this in the beginning of March. And it’s actually super powerful.
/superpowers:write-plan in Claude’s plan mode. Reads every doc generated above and breaks the spec into bite-sized tasks of 2–5 minutes each, with file paths and tests written down. When work can be parallelized it splits into subtrees. Some of my specs have come out as 50 bite-sized tasks across 3 parallel subtrees.
/superpowers:execute-plan is where coding starts. By this point most of the issues have been planned away so there are fewer surprises during implementation. I run it in subagent-driven-development mode and can walk away. Questions that come up can be addressed through Claude’s /remote-control from mobile. But if it is a brand new repository. We could run with — dangerously-skip-permissions. So it works autonomously. (Yeah that needs to be used with caution)
One rule I give it upfront: use Opus for critical tasks and anything that needs real reasoning. Use Sonnet for small, straightforward execution. Don’t use Haiku. Haiku is fast but not meant for code that’s going to ship, not worth the savings.
Reviews: For every task or task group, three reviewers run before anything gets accepted. A spec review checks the work matches what was planned. A code quality review checks for the usual things, structure, naming, edge cases, test coverage. A UX review checks the user-facing behavior.
Worth knowing: even on the Max plan, subagent-driven-development can hit rate limits. Sometimes, when I reach the limits in the day. Have run Claude overnight autonomously providing all the steps and documents it needs to refer.
Polish and Iterate
/design-review from gstack runs an 80-item visual audit on the live site, then enters a fix loop with one atomic commit per finding and before/after screenshots.
/ui-ux-pro-max is the alternative for design intelligence. Its database has 50+ styles, accessibility rules, and color systems, and it’s better when I want to apply a design direction than for raw audit. [ui-ux-pro-max]
Claude Cowork has design skills too for critique and accessibility audits, useful for a different lens.
Run a second iteration of planning and building with Superpowers. Same flow, smaller scope, fixes from the audit baked in. This creates a loop of iteration.
Another well-maintained option is Affaan Mustafa’s everything-claude-code, an Anthropic Hackathon winner with around 180 skills and 48 agents. Have recently started exploring some skills from it. Have used /security-review and /harness-audit from it. Can be used as an alternative to Superpowers for build.
The harness around the loop
For everything to run with less human in the loop, the supporting files have to do real work.
CLAUDE.md for standard decisions and commands. DESIGN.md for the current design system. Decisions get promoted to docs/decisions/ADR-*.md. Each spec and Superpowers plan gets its own folder. Every feature on its own branch and worktree.
All commits and pushes go through Claude. A custom /commit skill batches related changes, scopes them properly, and writes meaningful messages. Before pushing, Claude reviews its own diff for analytics and logging on new code paths and flags obvious security issues.
Husky pre-push hooks run the deterministic layer on top: unit tests, e2e tests, and functional tests through Playwright MCP or Chrome MCP.
Routines
Claude Code Routines are like automated agents performing everyday tasks based on API or time based like cron by chaining MCPs with custom skills from the repo. Daily research, outreach to generate business leads, auto-triaging new issues from the issue list. For engineers, that last one alone is meaningful time recovery.
For CricCheer, I have a /update-scores skill that pulls from Google and updates scores and the points table in the database. A routine fires it at the end of every IPL match. Zero maintenance from me.
The number of possibilities here is large. Worth a separate write-up of its own.
If you read this far and want more on Claude Code and building systems around AI, follow along.
