What a Real AI Workflow Looks Like for a Solo Developer
Most writing about AI developer tools is either product marketing or theoretical. This is an account of how AI tools actually get used in a real solo development workflow — specific tools, specific tasks, and honest assessment of where they help and where they slow things down.
The setup
The tools that form the core of this workflow:
- Cursor as the primary IDE (Pro, $20/month)
- Claude Pro for document analysis, architecture discussion, and writing tasks ($20/month)
- Claude Code for terminal-based autonomous tasks (included with Claude Pro)
- Perplexity for research and documentation lookup (free tier)
- Warp as the terminal (free)
Total cost: $40/month.
How Cursor gets used
Cursor Tab handles the majority of code completion. Its completions are better than GitHub Copilot on codebases it has indexed because it reads your whole project, not just the open file. For boilerplate, repetitive patterns, and test generation, it is faster than typing.
The more valuable feature is Cursor Chat in agent mode. For a task like "add pagination to this API endpoint and update the corresponding tests," agent mode reads the relevant files, writes the implementation, runs the tests, and fixes what fails. This task used to take 30-60 minutes. With agent mode, it takes 5-10 with brief review.
The failure mode to know: Cursor's agent makes assumptions when requirements are ambiguous. On a well-specified task with clear existing patterns, it works well. On vague tasks or tasks that require understanding product context it has not read, the output needs significant correction. The 15-minute task that becomes a 45-minute correction session is a recognizable failure mode.
The adjustment: treat Cursor like a capable contractor who needs a clear brief. "Add a GET /users/:id endpoint following the pattern in routes/users.ts, with input validation using the existing validator pattern, and a corresponding test file" works well. "Make the user profile feature better" does not.
How Claude Pro gets used
Claude's strength is not code generation — it is reasoning about code and systems.
The most valuable use case: architecture discussion. Describing a system design problem and asking Claude to identify the failure modes, alternative approaches, and trade-offs gets thoughtful analysis that generic documentation and Stack Overflow cannot match. This is most useful when making decisions that are expensive to reverse.
Second most valuable: document and PR review. Uploading a spec document, a contract, or a long pull request and asking for a summary of the important points and potential issues. Claude's 200K context window handles documents that would require hours to read carefully.
Third: writing tasks. API documentation, README files, technical blog posts, engineering RFCs. Claude produces competent first drafts that require editing but not rewriting.
How Claude Code gets used
Claude Code handles tasks that benefit from terminal-level access and automation that Cursor's chat does not provide.
The clearest use case: "I need to refactor how authentication is handled across these 12 files, following this pattern" — then letting Claude Code read all 12 files, propose the changes, and execute them. This is the kind of cross-codebase refactoring that would take a careful afternoon to do manually.
Also useful for: setting up new projects from scratch (create the directory structure, initialize the repo, configure TypeScript, set up the test framework), generating database migration scripts from schema changes, and wiring up integrations between services where the pattern is well-defined.
Claude Code's main cost consideration: it burns through context on large codebases. A session where it reads 30 files before acting is meaningfully expensive against your Pro subscription. For large codebases, being specific about which files are relevant before asking it to explore saves both cost and time.
How Perplexity gets used
Perplexity covers the documentation lookup use case: "what are the current best practices for handling OAuth tokens in a Next.js app?" or "what changed in this library between version 3 and version 4?"
The free tier handles this adequately. The cited sources are valuable for verifying that the answer is current. This is more reliable than asking Claude or ChatGPT, which may have outdated information from before their training cutoff.
What AI does not help with
Understanding your own product context. AI tools do not know why you made specific design decisions, what your users actually do, or what the business constraints are. When those factors drive a technical decision, AI gives generic advice that may not apply.
Debugging production incidents. AI is useful for explaining what a stack trace means or what a specific error typically indicates. It is not useful for diagnosing a live incident in a complex system where the relevant context lives in logs and metrics outside its reach.
The judgment calls. Whether to build or buy a specific feature, whether to take on technical debt now and pay later, whether this architecture will scale — these are judgment calls that require understanding your specific situation. AI tools are confident advisors with limited specific context.
The net assessment
$40/month for 20-30 hours of avoided work per week is easy math to justify. The tools that provide that return are Cursor Pro and Claude Pro.
The return is highest on well-defined implementation tasks where the pattern exists somewhere in the codebase, research and documentation tasks where current sources matter, and writing tasks where a competent draft is more valuable than starting from scratch.
The return is lowest on exploratory work, novel problems, and anything that requires understanding your specific product context. Those tasks still require full human attention.