The 5 prompts that save my week as a solo dev

I’m not going to list “prompt for writing emails” or “prompt for generating variable names”. You find that everywhere.

I’ll show the SYSTEM of prompts I use every week that saves 6-8 hours of my time. Each prompt solves a specific problem in my workflow as a solo dev.

Prompt 1: Analyze client brief (and extract unclear points)

Client sends a message like: “I need a website that sells courses. Integrates with Stripe, shows student progress, sends certificate at the end”.

3 hours later, during development, I discover he wants a custom PDF certificate with logo. And that “progress” includes a points system that converts to coupons. Things not in the brief.

Now I do this:

You are an experienced product manager.

A client requested the following:
[paste brief here]

Your task is:
1. List EXPLICITLY each feature requested
2. Identify 5-7 questions the brief leaves open
3. Ask for clarification about:
   - Integrations (which ones exactly?)
   - User flow (what happens after...?)
   - Edge cases (what if user has problem X?)
   - Sensitive data (what security is needed?)
   - Budget/timeline (is it realistic with these features?)

Format: enumerate features, then list of questions with bullets.

Typical output:

FEATURES REQUESTED:
- Course sales
- Stripe integration
- Progress tracking
- Certificate at end

OPEN QUESTIONS:
- Certificate as PDF or just link?
- Needs custom logo?
- How does refund work?
- Auto email when complete?

This saves 1-2 hours of clarification later. Because now I know the right questions to ask.

Prompt 2: Generate proposal scope (and auto-price)

After clarifying the brief, I need to write the scope. Before: typed everything manually.

Now:

You are an experienced developer who writes project scopes.

Based on these features:
[paste confirmed features here]

Generate a PROJECT SCOPE that:
1. Lists each feature as a "scope item"
2. For each item, estimate HOURS of development
3. Calculate: total hours * $30/hour USD = project value
4. Add 20% contingency
5. Final value

Format:
- Feature: Description
  Hours: X
  Value: $ Y

TOTAL: X hours
BASE VALUE: $ Y
CONTINGENCY (20%): $ Z
FINAL VALUE: $ W

Assume technology React + TypeScript + Supabase.

Output:

- Email/password authentication
  Hours: 6
  Value: $180

- Stripe integration
  Hours: 8
  Value: $240

- Teacher dashboard
  Hours: 12
  Value: $360

...

TOTAL: 38 hours
BASE VALUE: $1140
CONTINGENCY (20%): $228
FINAL VALUE: $1368

This takes 10 minutes to generate. Without Claude, would be 1-2 hours typing and thinking.

Prompt 3: Refactor and clean up PR (before merge)

A junior dev (or me) opens a PR with code that “works” but isn’t optimized.

Before merging, I run this prompt:

You are a senior developer doing code review.

Analyze this code:
[paste code or function here]

Identify:
1. Performance issues (duplicate loops? can be optimized?)
2. Pattern violations (follows project conventions?)
3. Potential bugs (missing error handling? edge cases?)
4. Readability (would someone new understand this?)
5. Type safety (if TypeScript, are types correct?)

For EACH finding, suggest a specific change with code.

Format:
PROBLEM: description
SUGGESTION: new code
BEFORE: current snippet
AFTER: improved snippet

Typical output:

PROBLEM: Unnecessary loop that runs N times
SUGGESTION: Use .find() instead of loop with break
BEFORE:
let found = null;
for (let i = 0; i < users.length; i++) {
  if (users[i].id === targetId) {
    found = users[i];
    break;
  }
}

AFTER:
const found = users.find(u => u.id === targetId);

This saves review time and ensures code that merges is decent. I spend 15 minutes on review instead of 45.

Prompt 4: Review contract (and find problematic clauses)

Clients sometimes send an NDA or partnership contract. Before I’d ignore it or skim quickly.

Now:

You are a lawyer analyzing contracts.

Analyze this contract:
[paste text here]

Identify:
1. Clauses that favor one party over another
2. Legal ambiguities (what is vague or open to interpretation?)
3. Risks for me as a developer (am I responsible for what?)
4. Red flags (exclusivity? abusive confidentiality? geographic restriction?)
5. Recommendations (what should be here but isn't?)

Disclaimer: I am not a lawyer, this is technical analysis, not legal advice.
Seek professional counsel for critical contracts.

Format:
CLAUSE: number/title
RISK: level (HIGH/MEDIUM/LOW)
PROBLEM: description
RECOMMENDATION: what to change

Output:

CLAUSE: 3.2 - Confidentiality
RISK: HIGH
PROBLEM: "Any information shared stays confidential indefinitely"
RECOMMENDATION: Limit to 3-5 years. Add public information exception.

CLAUSE: 5.1 - Liability
RISK: MEDIUM
PROBLEM: "Developer responsible for bugs 12 months after deployment"
RECOMMENDATION: Reduce to 30 days and only critical bugs (security).

Saves 2-3 hours of reading/analysis. And prevents me from falling into abusive clauses.

Prompt 5: Generate SQL for complex migration

I have a database in production. Need to migrate data one way, change schema. Migration is always risky.

This prompt helps:

You are an expert PostgreSQL DBA.

I need to migrate data:
ORIGINAL TABLE: [describe structure]
NEW TABLE: [describe structure]

Generate:
1. Validation: count records before and after (should be equal)
2. Transformation: SQL to copy and transform data
3. Cleanup: delete redundant/old data
4. Verification: query to audit migration

Assume sensitive data. Include:
- Backup before running
- Integrity validation (foreign keys)
- Test in staging first
- Rollback plan

Format:
-- BACKUP
-- PRE-MIGRATION VALIDATION
-- TRANSFORMATION
-- CLEANUP
-- POST-MIGRATION VERIFICATION

Output:

-- BACKUP
pg_dump your_database > backup_$(date +%Y%m%d).sql

-- PRE-MIGRATION VALIDATION
SELECT COUNT(*) FROM old_table; -- Save this number

-- TRANSFORMATION
INSERT INTO new_table (id, name, email, created_at)
SELECT id, name, email, created_at FROM old_table
WHERE deleted_at IS NULL;

-- VERIFICATION
SELECT COUNT(*) FROM new_table; -- Should equal previous COUNT

This prevents me from forgetting critical steps and corrupting data. Savings: debugging time if something breaks, which could be hours.

System, not list

Why these prompts work is they’re not “generic”. They’re SPECIFIC to my workflow:

• Prompt 1 solves vague brief problem
• Prompt 2 solves manual pricing problem
• Prompt 3 solves slow code review problem
• Prompt 4 solves unclear contracts problem
• Prompt 5 solves risky migration problem

Each saves time at the exact point where I waste the most time.

How you find YOUR prompts

Track one week. Where do you spend more than 1 hour on repetitive tasks?

• Writing similar emails? Create a prompt to structure the response.
• Debugging the same bug type? Create a prompt for auto-analysis.
• Reviewing old documentation? Create a prompt that summarizes and updates.

Once you find them, refine 3-4 times. First output is rarely perfect.

Time saved total

Weekly estimate with detail:

• Brief (1-2h) -> 10-15 min with prompt = 1h saved
• Scope (1-2h) -> 15 min with prompt = 1h saved
• Code review (2-3h) -> 30-45 min with prompt = 1.5h saved
• Contract (2-3h) -> 20 min with prompt = 2h saved
• SQL migration (1-2h) -> 20 min with prompt = 1h saved

Total: 6.5-7 hours saved per week.

In a month, that’s 26-28 hours. In a year, 338 hours. That’s 8-9 weeks of work returned to your calendar.

But there’s something bigger here: those 7 hours aren’t just “time saved”. They’re hours where you were operating in reactive mode (debugging, trying to parse a confusing client email, waiting for migration to finish). Now you operate in creative mode: actual architecture decisions, code that matters, strategic conversations. Your quality of life goes up even if the “saved” time was only 2 hours.

That’s why prompts work better than random hacks: they reorganize your workflow to make space for work that actually counts.

Why these 5 work when

When prompts fail

Prompts fail when context is missing. Example: you ask “generate code for validation” and the model generates basic email validation. But you needed RFC 5322 compliant validation that rejects common false positives.

Solution: specify constraints upfront. “Generate email validation in TypeScript. Must comply with RFC 5322, reject emails ending in .test or .local, handle plus addressing, return boolean not exception”.

Another common failure: long prompts where the model loses focus halfway. Solution is to split into sub-prompts. Prompt 1 defines structure. Prompt 2 builds part A. Prompt 3 builds part B. Each prompt is specific and short.

The pattern: specific beats generic. Detailed beats vague. Constraints eliminate guesswork.

Prompt 5: Code review checklist

Review this code for:
1. Security flaws (injection, exposed secrets, permission issues)
2. Performance issues (N+1 queries, unnecessary loops, large data transfers)
3. Maintainability (unclear variable names, missing comments, complex logic)
4. Error handling (are all exceptions caught and logged?)
5. Testing (are critical paths tested?)

Code to review:
[paste code]

Format as: issue type, severity (critical/medium/low), explanation, suggested fix.

This saves me 20 minutes per PR review.

The system effect

Each prompt saves 45 minutes. Use 5 prompts daily = 225 minutes = 3.75 hours per day. Over 5 days = 18.75 hours per week.

Realistically, you won’t use all 5 every single day. But even 3 prompts daily saves 10-12 hours per week.

That’s how “5 prompts save my week” literally.

Building your own prompt library

Don’t copy my prompts. Build prompts for YOUR workflow. Ask yourself: what task takes 1+ hour and happens weekly? That’s a candidate for automation via prompt.

Template: “What is the output? What are the constraints? What format should it be?”. Then write a prompt that answers those three things clearly.

Test it 3 times. Refine based on actual output. Once it works consistently, add to your saved prompts.

Read also: Building a custom MCP server | Vibe coding vs AI pair programming | Deliver projects faster with AI