name: cost-estimate description: Estimate development cost of a codebase based on lines of code and complexity

Cost Estimate Command

You are a senior software engineering consultant tasked with estimating the development cost of the current codebase.

CRITICAL: Not all code is created equal. The majority of modern codebases consist of scaffolded, copied, or generated code that should NOT be valued at full custom development rates.

Step 1: Analyze and CATEGORIZE the Codebase

First, count total lines. Then categorize each file into one of these tiers:

Code Value Tiers

How to Categorize

Tier 1 indicators (100% value):

• Contains business-specific logic (pricing, rules, workflows)
• Has custom algorithms or data transformations
• Non-trivial error handling for real edge cases
• Would require understanding the business to write

Tier 2 indicators (75% value):

• Custom UI components built for this project
• Project-specific layouts and page structures
• Custom hooks with real logic
• Styled components with original designs

Tier 3 indicators (40% value):

• Integration code (Stripe, Auth0, Cloudflare, etc.)
• API route handlers that mostly call external services
• Database schema definitions
• Queue/worker configurations

Tier 4 indicators (15% value):

• Components from shadcn/ui, Radix, or similar
• Next.js/Remix page boilerplate
• Standard CRUD operations
• Copy-pasted patterns from docs

Tier 5 indicators (5% value):

• tsconfig.json, eslint.config.js, tailwind.config.js
• package.json, wrangler.toml
• Docker/CI configs from templates
• Generated types, migrations from CLI tools

Tier 6 indicators (0% value):

• MDX/Markdown content files
• README, CHANGELOG, docs
• Comments and JSDoc (unless documenting complex logic)

Categorization Commands

Run these to identify code categories:

# Find UI library components (Tier 4)
ls src/components/ui/ 2>/dev/null | wc -l

# Find config files (Tier 5)
ls *.config.* *.json wrangler.toml tsconfig.json 2>/dev/null

# Find content files (Tier 6)
find . -name "*.md" -o -name "*.mdx" | wc -l

# Find test files (apply 50% modifier - tests have high boilerplate)
find . -name "*.test.*" -o -name "*.spec.*" | xargs wc -l 2>/dev/null

Calculate Effective Lines of Code

Effective LOC = Σ (Lines in Category × Value %)

Example:

• 500 lines custom business logic × 100% = 500 effective
• 2000 lines custom UI × 75% = 1500 effective
• 800 lines integrations × 40% = 320 effective
• 3000 lines shadcn/ui × 15% = 450 effective
• 600 lines config × 5% = 30 effective
• 1000 lines content × 0% = 0 effective
• Total: 7900 raw LOC → 2800 effective LOC

Step 2: Calculate Development Hours (using Effective LOC)

Based on industry standards for a senior full-stack developer (5+ years experience):

Hourly Productivity Estimates (applied to EFFECTIVE lines only):

• Complex business logic: 15-25 lines/hour
• Custom UI/components: 25-40 lines/hour
• Integration code: 30-50 lines/hour
• Standard patterns: 40-60 lines/hour

Test Code Modifier: Tests are typically 50% boilerplate. Apply 0.5x to test line counts before categorization.

Additional Time Factors:

• Architecture & design: +15% of coding time
• Debugging & troubleshooting: +20% of coding time
• Code review & refactoring: +10% of coding time
• Integration & testing: +15% of coding time

Calculate total hours:

Base Hours = Effective LOC / Productivity Rate
Total Hours = Base Hours × (1 + Overhead %)

Step 3: Research Market Rates

Use WebSearch to find current hourly rates for senior developers.

Search queries:

• "senior full stack developer hourly rate [current year]"
• "senior software engineer contractor rate United States [current year]"

Typical ranges (2025-2026):

• Remote/mid-market: $75-100/hr
• US average: $100-150/hr
• Premium markets (SF/NYC): $150-200/hr

Step 4: Calculate Organizational Overhead

Real companies don't have developers coding 40 hours/week.

Coding Efficiency Factor:

• Solo/Startup (lean): 65% coding time (~26 hrs/week)
• Growth company: 55% coding time (~22 hrs/week)
• Enterprise: 45% coding time (~18 hrs/week)

Calendar Time:

Calendar Weeks = Total Dev Hours / (40 × Efficiency Factor)

Step 5: Generate Cost Estimate

Important: Present BOTH the raw LOC count AND the effective LOC calculation to show the methodology clearly.

Output Format

[Project Name] - Development Cost Estimate

Analysis Date: [Current Date]

Code Categorization

Effective LOC Ratio: [Effective/Raw]% — This is a [typical/lean/heavy] scaffold ratio.

Development Time Estimate

Using [Effective LOC] effective lines:

Overhead: +60% (architecture, debugging, review, testing)

Total Estimated Hours: [X] hours

Cost Estimate

Recommended Estimate: $[X] - $[X]

Calendar Time

Step 6: Claude ROI Analysis (if applicable)

If this codebase was built with Claude:

Project Timeline:

• First commit: [date]
• Latest commit: [date]
• Total calendar time: [X] days

Claude Active Hours Estimate: Cluster commits into sessions (4-hour windows), estimate 1-4 hours per session based on commit density.

Value per Claude Hour:

$/Claude Hour = Total Cost Estimate / Claude Active Hours

Speed Multiplier:

Speed = Human Hours / Claude Hours

Common Mistakes to Avoid

1. Counting all lines equally - A 50K LOC project with 40K lines of scaffolding is NOT a $500K project
2. Including content as code - MDX blog posts are writing, not development
3. Full-valuing test boilerplate - Test setup/mocking is highly repetitive
4. Ignoring the scaffold ratio - Modern frameworks generate 50-80% of typical codebases

Sanity Checks

Before finalizing, ask:

• Could a competent developer recreate this in [X] weeks? Does the estimate match?
• What % is truly novel vs. "npm install + copy docs"?
• Does the estimate pass the "would I pay this?" test?

A realistic solo web project typically costs $10K-50K, not $100K+. Anything higher requires exceptional complexity justification.