The Workflows Nobody Teaches You
Most developers use AI coding tools like a glorified autocomplete. They accept line-by-line suggestions and call it a productivity gain. That is like using a Formula 1 car to drive to the grocery store.
The real power comes from building repeatable workflows — patterns you use daily that compress hours of work into minutes. After months of building my startup almost exclusively with Claude Code, I have settled on ten workflows that account for most of my productivity gains.
Workflow 1: The Full-Feature Scaffold
Instead of building features incrementally (route, then handler, then database, then tests), I describe the entire feature in one prompt:
- What the feature does
- What data it needs
- What the API endpoints look like
- What the error cases are
- What tests should cover
Claude Code generates the complete implementation across all files. I review, adjust, and ship. What used to take a full day now takes a focused hour.
When to use it
New features with well-understood requirements. Not for exploratory work where you are still figuring out what you want.
Workflow 2: The Test-First Description
I describe the behavior I want in plain language, ask for tests first, then ask for the implementation that passes those tests. This is AI-assisted TDD:
- "Write tests for a function that calculates subscription proration when a user upgrades mid-cycle"
- Review the tests, adjust edge cases
- "Now write the implementation that passes these tests"
This produces better code than asking for the implementation directly because the tests force specificity.
When to use it
Business logic with edge cases. Billing, permissions, data transformations.
Workflow 3: The Codebase-Wide Refactor
When I need to rename a concept, change an interface, or update a pattern across the entire codebase, I describe the change once and let Claude Code apply it everywhere.
Example: "Rename all instances of 'user' to 'account' in the authentication module, including variable names, function names, database columns, API routes, and test files."
Doing this manually would take hours and inevitably miss something. AI catches everything.
When to use it
Any systematic change that touches many files. Schema migrations, API versioning, naming convention updates.
Workflow 4: The Bug Detective
Instead of staring at code trying to find the bug, I describe the symptom:
- "Users report that their session expires after exactly 15 minutes even though the timeout is set to 60 minutes. Here is the relevant code..."
Claude Code traces the logic, identifies the conflict (often a default configuration overriding the custom one), and suggests the fix with an explanation of why it happens.
When to use it
Any bug where you can describe the symptom clearly. Especially useful for configuration conflicts and subtle logic errors.
Workflow 5: The API Integration Express
Integrating with a third-party API used to mean reading docs for an hour, writing a client, handling errors, and building tests. Now:
- "Integrate with the Stripe API to handle subscription creation, updating, and cancellation. Include webhook handling for payment failures and retry logic."
The implementation follows standard patterns and handles edge cases that I would have discovered only after hitting them in production.
When to use it
Any third-party API integration. Payment processors, email services, analytics platforms, CRM systems.
Workflow 6: The Documentation Generator
After building a feature, I ask Claude Code to generate documentation from the code:
- API documentation from route handlers
- README sections from module structure
- Architecture decision records from git history
- Onboarding guides from codebase patterns
This produces documentation that is always in sync with the code because it is generated from the code.
When to use it
After completing any significant feature. Before onboarding a new team member. When preparing for an architecture review.
Workflow 7: The Performance Audit
I describe a performance concern and ask for analysis:
- "This database query is slow when the users table has more than 100,000 rows. Analyze the query, suggest indexes, and rewrite if necessary."
Claude Code identifies missing indexes, N+1 queries, unnecessary joins, and suggests optimizations with explanations of the tradeoffs.
When to use it
When response times degrade. Before launching a feature that will handle significantly more traffic. During quarterly performance reviews.
Workflow 8: The Migration Builder
Database migrations are error-prone and tedious. I describe the desired state:
- "Add a 'team' concept to the system. Each user belongs to one team. Teams have a name, plan, and billing email. Migrate existing users to individual teams."
Claude generates the migration, the rollback, the model updates, and the data migration script.
When to use it
Any database schema change. Especially useful for complex migrations that involve data transformation.
Workflow 9: The Security Review
Before deploying sensitive features, I ask for a security review:
- "Review this authentication flow for common vulnerabilities: SQL injection, XSS, CSRF, session fixation, and timing attacks."
This catches issues that are easy to miss when you are focused on functionality. It is not a replacement for a professional security audit, but it catches the low-hanging vulnerabilities.
When to use it
Before deploying any feature that handles user input, authentication, or payment data.
Workflow 10: The Competitive Teardown
This one is not about code. I use Claude Code to analyze competitor implementations:
- "Look at this API response from a competing product. What does their data model look like? What design decisions did they make? What are the tradeoffs?"
This gives me product intelligence that informs my own architecture decisions.
When to use it
During product planning. When deciding between implementation approaches. When evaluating build-vs-buy decisions.
The Meta-Workflow: Building Workflows
The most powerful thing about AI-assisted development is that you can create custom workflows for your specific product. Every recurring task in your development process is a candidate for an AI workflow.
Ask yourself: what do I do repeatedly that requires more execution than thinking? That is your next workflow.
FAQ
How long did it take to develop these workflows?
About two to three months of daily use. The key was paying attention to where I spent time and asking "could AI handle this faster?"
Do these workflows work with any AI coding tool?
The patterns transfer to most AI coding tools. The specific implementation varies, but the approach of describing intent rather than writing implementation works universally.
What is the biggest time savings?
The full-feature scaffold (Workflow 1) and the codebase-wide refactor (Workflow 3) save the most time. Each one compresses what used to be a multi-day effort into an hour or less.
Do you still write code manually?
Yes, for exploratory work where I am still figuring out the approach. When the problem is well-defined, AI handles the implementation. When it is ambiguous, I prototype manually until the solution is clear.