cost-estimate

Files (1)

• SKILL.md

SKILL.md (first lines)

# 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

| Tier | Value % | Description | Examples |
|------|---------|-------------|----------|
| **Tier 1: Custom Business Logic** | 100% | Novel code solving unique problems | Custom algorithms, business rules, API handlers with real logic |
| **Tier 2: Custom UI/Components** | 75% | Project-specific UI built from scratch | Custom React components, layouts, animations |
| **Tier 3: Configured Integrations** | 40% | Third-party services wired together | Auth setup, payment integration, API clients |
| **Tier 4: Adapted Library Code** | 15% | Copy-pasted with minor changes | shadcn/ui components, Next.js app router pages |
| **Tier 5: Pure Scaffold/Config** | 5% | Generated or copy-pasted verbatim | Config files, boilerplate, package.json |
| **Tier 6: Content (not code)** | 0% | Text content, documentation | MDX blog posts, README files |

### 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:

```bash
# 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.

From danzam98/claude-skills-toolkit, MIT.

More from danzam98/claude-skills-toolkit