The Workflows That Actually Work
Concrete patterns for shipping features, fixing bugs, and running code reviews with Claude Code
Over nearly two months, I've run 338 sessions with an impressive 79% full or mostly achieved outcome rate, leveraging Claude Code as a deeply integrated daily driver across knowledge management, web development, and deployment workflows.
But "it works well" isn't very useful advice. What specifically works? What patterns can you steal?
Obsidian Vault as Knowledge Operating System
I've built and continuously evolved a comprehensive Obsidian second brain for my Director of Intelligent Systems role, using Claude to process meeting transcripts, create structured project briefs, maintain people/org notes, and generate weekly reports. My iterative approach — feeding in raw stakeholder messages, transcripts, and API docs and having Claude maintain structured vault notes across dozens of sessions — turns Claude into a persistent knowledge worker that keeps my institutional memory organized and actionable.
Full Feature Lifecycles in Single Sessions
I consistently drive entire feature lifecycles — from implementation through code review, PR creation, bug fixes, and deployment — all within single sessions. Whether it's a Stripe Connect integration, page ownership transfer, or a third-party service connector wiring across three agent systems, I stay in the loop correcting course (like catching a race condition or timezone bug) while letting Claude handle the multi-file heavy lifting across my TypeScript codebase.
Parallel Sub-Agent Orchestration at Scale
I'm heavily leveraging Claude's Task and TaskUpdate tools (over 1,400 combined uses), running parallel sub-agents for architecture audits, code reviews, and multi-file changes that span my entire codebase. My 108 successful multi-file change operations show I've built a workflow where Claude can confidently touch many files at once, and I trust it enough to let it operate broadly while stepping in precisely when it drifts — like when it misplaced action items in the wrong project files or overclaimed campaign status.
End-to-End Feature Lifecycle Management
I consistently drive features from planning through implementation, code review, PR creation, and deployment in single sessions — exemplified by my Calendly connector (12 files, 1,352 lines), Stripe Connect integration, mobile responsive overhaul (883 additions across 18 files), and page ownership transfer feature. My ability to chain planning, coding, review, and merge steps into fluid workflows shows a mature engineering process powered by Claude Code.
Obsidian Second Brain Construction
I've built out a sophisticated Obsidian knowledge management system using Claude Code as my content engine — scaffolding vault structures, populating person notes and org charts, creating onboarding plans as structured notes, processing meeting transcripts into actionable items, and even building an automated weekly report skill. This creative use of a coding tool for structured knowledge work is highly effective and shows me thinking beyond traditional IDE workflows.
Parallel Sub-Agent Architecture Audits
I'm leveraging Claude's Task/TaskUpdate tools (over 1,500 combined uses) to run parallel sub-agents for complex operations like architecture audits that scored my codebase across multiple dimensions simultaneously. This sophisticated orchestration pattern, combined with my high success rate (81% fully or mostly achieved outcomes across 178 analyzed sessions), demonstrates I've figured out how to keep Claude focused and productive at scale.
End-to-End Feature Lifecycle Mastery
I consistently drive features from planning through implementation, code review, PR creation, and deployment all within single sessions. Whether it's a Calendly connector (1,352 lines across 12 files), a full Stripe Connect integration, or mobile responsive overhauls spanning 18 files, I treat Claude as a full-cycle engineering partner rather than just a code generator. My ability to chain tasks — implement, review, fix, merge, deploy — keeps momentum high and ships features fast.
Rapid Bug-Fix-to-PR Pipeline
I've developed an incredibly efficient bug fix workflow where I feed Claude a plan or QA report, have it implement fixes across multiple files, run code review, address findings, and push a PR — sometimes completing the entire cycle in under 10 minutes. My pattern of combining bug fix implementation with inline code review before shipping means I catch issues early while maintaining a high velocity of 256 commits across the period.
The Pattern Behind the Patterns
Every workflow above shares a common structure: clear scope, autonomous execution, verification gate, ship.
The temptation with AI coding tools is to micromanage — describe each function, review each file, approve each change. That's the slow way. The fast way is to describe the outcome you want, let Claude figure out the implementation, then verify the result against your actual quality bar (type checks, builds, tests, visual inspection).
The mental model that works: Think of Claude as a contractor, not an employee. You don't tell a contractor which nails to use — you describe the finished product and inspect the work.
What Doesn't Get Talked About Enough
The biggest unlock wasn't any single technique. It was building trust over time. After watching Claude successfully implement a complex connector across 12 files and 1,352 lines in a single session, I started scoping much more ambitiously. That compounding trust is the real force multiplier.
The flip side: trust needs to be calibrated. Claude will confidently ship code with subtle bugs (more on that in Where Things Go Wrong). The right balance is high trust on implementation, zero trust on correctness until verified.