Skip to content

teterouge/codeworth

repo-estimator

Verified

Analyze a code repository and produce a detailed human time and cost estimate for building it from scratch. Use this skill whenever the user wants to know how long it would take a human developer or team to build a codebase, how much it would cost to recreate a project, what the engineering effort of a repo is, or wants a "what's this worth?" / "how much work went into this?" type of analysis. Also trigger for requests like "estimate this project", "how many dev hours is this", "what would it cost to build this", "audit this repo for effort", "scope this codebase", or any time someone shares a repo path or GitHub URL and asks about effort, time, team size, or cost. Even if they don't use the words "estimate" or "cost" — if they share code and ask about effort or what it would take to build, use this skill.

references/pm-effort-guide.md

View on GitHub
# PM Effort Guide

When estimating a product run by a human team, product management is a real cost that must be estimated separately from engineering. This guide explains how to read a repository for PM effort signals and calculate PM hours.

---

## What PM Effort Covers

Product manager time breaks into several categories that are distinct from engineering:

**Discovery & research** — User interviews, competitive analysis, market research, defining the problem space. The output shows up indirectly in product decisions baked into the code.

**Specification & planning** — Writing PRDs, user stories, acceptance criteria, API contracts. Evidence: spec directories, detailed changelogs, ADRs, versioned API docs with clear behavioral descriptions.

**Stakeholder management** — Alignment meetings, executive reviews, sales engineering support, customer calls. Not visible in code but proportional to product complexity and number of user types.

**Prioritization & roadmap work** — Deciding what gets built, in what order, for whom. Every product feature represents PM decisions upstream.

**Acceptance testing & release coordination** — Validating builds against specs, coordinating launches, writing release notes. Evidence: CHANGELOG entries, release tags, migration guides.

**Post-launch analysis** — Reviewing analytics, triaging feedback, defining iterations. Evidence: multiple versions of the same feature, A/B test code, feature flags, gradual rollout logic.

---

## How to Estimate PM Hours from Repo Signals

### Step 1: Count Distinct Product Features

Walk the repo and identify distinct user-facing capabilities — not technical components, but things a user or customer would describe as "the product does X."

Examples:
- User account management (signup, login, profile, deletion)
- Dashboard with analytics widgets
- File upload and processing pipeline
- Team collaboration and sharing
- Billing and subscription management
- Admin panel for internal operators
- Public API with developer documentation

A feature like "user authentication" is one PM feature, even though it might span 10 files. A feature like "multi-currency billing with prorations and invoice generation" is meaningfully more PM work than "basic Stripe subscription."

**Rule of thumb**: 8–20 hours of PM work per distinct feature for a B2B SaaS, depending on complexity. Discovery-heavy features (novel user experiences, complex workflows) run higher. Table-stakes features (standard auth, basic CRUD) run lower.

---

### Step 2: Read the Evidence of PM Artifacts

Look for signals in the repo that indicate how much PM rigor was applied:

**High PM signal (more hours):**
- `/docs/specs/`, `/docs/prd/`, or similar directories with design documents
- Detailed ADRs (Architecture Decision Records) — these are often written or prompted by PM decisions
- Comprehensive CHANGELOG with feature descriptions, not just commit hashes
- OpenAPI/Swagger specs with detailed descriptions, examples, and error codes
- Feature flags or A/B testing infrastructure — implies experimentation and iteration
- Multiple major versions of an API or UI pattern (v1, v2, etc.) — implies planned evolution
- Separate staging/canary/production environments — implies release management
- User-facing error messages written with care — implies PM-specified copy
- Granular permissions/roles system — implies extensive PM work on user types and access models
- Onboarding flows, tooltips, empty states — implies PM designed the full user journey

**Low PM signal (fewer hours):**
- README-only documentation
- No changelogs or minimal commit messages
- Single API version with no versioning strategy
- No feature flags or experimentation code
- Basic error handling without user-facing copy
- Solo developer repo with no evidence of team coordination

---

### Step 3: Assess Product Complexity

Product complexity is not the same as technical complexity. A technically simple app can require enormous PM effort if:
- It serves multiple distinct user types (customers, admins, vendors, support agents)
- It has regulatory requirements (healthcare, finance, legal)
- It involves external stakeholders (partner integrations, enterprise customers, API consumers)
- It requires consensus across teams or business units
- It has complex pricing or packaging decisions

**Signals of high stakeholder complexity:**
- Multi-tenant architecture with organization/workspace concepts
- Role hierarchies with 4+ distinct roles
- Partner/vendor portals alongside customer-facing features
- Compliance-adjacent features (audit logs, data retention, export capabilities, GDPR tooling)
- White-labeling or multi-brand support
- Sales-assisted signup flows (enterprise tier indicators)

---

### Step 4: Apply the Right Ratio

Use the ratios from `references/rate-cards.md` as your baseline:

| Product Type | PM Hours as % of Engineering Hours |
|-------------|-------------------------------------|
| Internal tool / admin panel | 5–10% |
| Developer tool / API / SDK | 10–15% |
| B2B SaaS product | 15–25% |
| B2C consumer product | 20–30% |
| Multi-sided marketplace | 25–35% |
| Enterprise platform (complex stakeholders) | 30–40% |

**Adjust up if:**
- Multiple user types with distinct workflows
- Evidence of significant experimentation (feature flags, A/B tests)
- Complex pricing / packaging decisions baked into the code
- Regulatory compliance features (implies PM-driven compliance work)
- External-facing API with developer experience considerations

**Adjust down if:**
- Solo developer project (PM = developer themselves, already counted)
- Pure internal tool with a single user type
- Open source project where PM is community-driven

---

### Step 5: Calculate PM Cost

Once you have PM hours:

```
PM Cost = PM Hours × PM Hourly Rate
```

Use $110/hr (mid-senior PM, US) as the default unless specified otherwise. See `references/rate-cards.md` for regional rates.

**Express PM hours as a separate line item in the report**, not folded into engineering hours. This makes it easy for the user to adjust independently.

---

## Output Format for PM Section

Add this section to the report between "Recommended Team" and "Cost Estimate":

```
## Product Management Effort

**PM effort estimation basis**: [Describe what signals drove the estimate — e.g., 
"12 distinct product features identified, B2B SaaS with 3 user types, evidence 
of spec documents in /docs/"]

**Estimated PM hours**: [N] hours  
**PM-to-engineering ratio applied**: [X%] ([product type category])

| PM Activity | Estimated Hours | Evidence |
|-------------|----------------|----------|
| Discovery & user research | [N] | [what signals suggest this] |
| Specification & story writing | [N] | [what signals suggest this] |
| Stakeholder & roadmap management | [N] | [what signals suggest this] |
| Acceptance testing & release coordination | [N] | [what signals suggest this] |
| Post-launch analysis & iteration | [N] | [what signals suggest this] |
| **Total PM hours** | **[N]** | |

**PM Cost**: $[N] at $[rate]/hr ([seniority, region])
```

---

## PM Estimation Notes for Common Repo Patterns

**API-only repos (no frontend)**
PM effort is lower but not zero — API design, developer experience, documentation strategy, and versioning policy all require PM attention. Use 10–15% of engineering hours.

**Admin-only panels**
These are often built to spec for internal operators. PM effort is light — mostly requirements gathering from the internal team. Use 5–8%.

**Multi-product monorepos**
Estimate PM per product or major surface, then sum. Don't apply a single ratio to the whole monorepo — different products within it may have very different PM intensity.

**Solo developer projects**
If the repo shows all the hallmarks of a solo project (single contributor in git, no team structure in code), the developer was their own PM. Don't double-count — note that PM time is folded into the engineering estimate rather than adding it separately.

**Open source projects**
Community-driven OSS has distributed PM effort (issues, RFCs, mailing lists, contributor discussions). This is genuinely hard to estimate from the repo alone. Note the limitation and provide a range rather than a point estimate.
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall