cost-model
À propos
Cette compétence fournit un cadre standardisé d'estimation des coûts pour les plans techniques, exigeant des ventilations explicites des coûts liés aux LLM, à l'infrastructure et à la supervision humaine. Elle impose un format de sortie spécifique et analysable pour l'intégration avec l'API du conseil et est utilisée lors de la rédaction de plans, de la prévision de l'utilisation des LLM ou de l'établissement de revendications d'économies. Le cadre garantit que toutes les estimations de coûts sont vérifiables et défendables.
Installation rapide
Claude Code
Recommandénpx skills add avelikiy/great_cto -a claude-code/plugin add https://github.com/avelikiy/great_ctogit clone https://github.com/avelikiy/great_cto.git ~/.claude/skills/cost-modelCopiez et collez cette commande dans Claude Code pour installer cette compétence
Documentation
Cost model — make cost claims defensible
great_cto reports cost numbers on the board. Those numbers MUST be auditable, because a wrong "7,638×" claim killed credibility (see docs/blog/cost-dashboard-rebuild.md). This skill defines the format.
The 4-line cost section
Every PLAN-.md and ARCH-.md cost section follows this exact template:
## Cost estimate
**LLM**: $<low>–<high> (<N> calls × $<per-call avg>)
**Human equiv**: $<low>–<high> (<hours> × $<rate>/h)
**Infra delta**: $<low>–<high>/month
**Time to ship**: <hours> agent-time, <hours> wall-clock
> Methodology: <one-sentence rationale for each range>
Why this exact format?
The board's getCostHistory() parser anchors on line-start "LLM" and
"Human" labels. Mid-line references are ignored to prevent the
$240-trap regression. Stick to the template.
How to estimate each line
LLM cost
For each agent in the pipeline, estimate:
- Prompt tokens = (system prompt size) + (context the agent receives)
- Completion tokens = (typical output for that agent type)
Quick reference for Sonnet 4 ($3/M in, $15/M out):
| Agent | Typical prompt | Typical output | Per-call cost |
|---|---|---|---|
| architect | 14k | 1.5k | ~$0.06 |
| pm | 6k | 0.6k | ~$0.03 |
| senior-dev | 8k | 0.8k | ~$0.04 |
| qa-engineer | 11k | 0.5k | ~$0.04 |
| reviewer (avg) | 8-12k | 0.6k | ~$0.04 |
| security-officer | 12k | 1k | ~$0.05 |
| devops | 9k | 0.8k | ~$0.04 |
For Haiku ($0.80/M / $4/M), divide by ~4. For Opus 4 ($15/M / $75/M), multiply by ~5.
Sum across the pipeline stages that actually fire (use gatesFor() and
reviewersFor() from archetypes.ts to know the count).
Human equiv
The human cost to do the SAME work without agents. This is the "if I hired a senior engineer, how long would this task take, at what rate?"
- Senior engineer: $120-180/hour (mid-market US/EU)
- Staff engineer / specialist: $200-300/hour
- Domain expert (security, compliance): $250-400/hour
Estimate hours conservatively. A "small feature" the LLM does in 15 minutes might take a human 2-4 hours (it's never just the typing).
Infra delta
Only count what's NEW. If the feature adds a Redis instance, count Redis. If it adds 10MB/month of S3 storage, that's noise — don't list.
Time to ship
Two numbers — both useful:
- Agent-time: wall-clock of LLM calls (typically 5-30 min)
- Wall-clock: actual elapsed including human gates (typically hours to days)
Sanity check before writing
Before committing the section to the plan, verify:
ratio = human_equiv / llm_cost
If ratio > 1000, something is wrong. Common bugs:
| Bug | How to detect | Fix |
|---|---|---|
| Wrong unit ($ vs ¢) | LLM cost ends in /M tokens not $ | Convert: tokens / 1M × price |
| Counting savings not spend | "Human time saved" not "Human cost" | Use cost of doing it, not value of skipping |
| Mid-line label pollution | Plan has "$X LLM | $Y human" on one line |
| Forecast vs actual mixed | LLM forecast counts toward total_llm | Separate forecast section if needed |
Cost gates
For AI archetypes (mlops, ai-system, agent-product), the pipeline
opens gate:cost after architect's forecast. CTO must approve the
projected monthly burn before senior-dev starts.
Use the GATE template:
## Gate:cost forecast
| Production volume | Monthly LLM cost |
|---|---|
| 1K req/day | $X |
| 10K req/day | $Y |
| 100K req/day | $Z |
Recommended monthly cap: $<cap>
Triggers above cap: <what alerts fire, who gets paged>
Anti-patterns
❌ Round-number theatre. "$0.50 LLM | $7,500 human" — looks suspicious. Use realistic ranges: "$0.50–1.20 | $225–360".
❌ Single point estimates. Always provide a range. Single numbers hide uncertainty.
❌ No methodology line. Just numbers without rationale is unverifiable.
❌ Hand-waved infra. "Some hosting cost" is not a number. Either give $, or say "infra: no change."
Example — good
## Cost estimate
**LLM**: $0.75–1.85 (3 tasks × $0.25–0.62 per Sonnet call)
**Human equiv**: $225–300 (1.5–2h × $150/h, mid-market senior)
**Infra delta**: $0/month (uses existing Express + Postgres)
**Time to ship**: ~15min agent-time, ~3h wall-clock (1 human gate)
> Methodology: tasks sized by line-count estimate; per-call cost from
> historical Sonnet 4 averages on this archetype's plans.
Ratio = 300/1.85 = 162×. Plausible. Defensible.
Dépôt GitHub
Compétences associées
executing-plans
DesignUtilisez la compétence executing-plans lorsque vous disposez d'un plan de mise en œuvre complet à exécuter par lots contrôlés avec des points de contrôle de revue. Elle charge et examine le plan de manière critique, puis exécute les tâches par petits lots (3 tâches par défaut) tout en rapportant la progression entre chaque lot pour une revue par l'architecte. Cela garantit une mise en œuvre systématique avec des points de contrôle de qualité intégrés.
requesting-code-review
DesignCette compétence délègue un sous-agent réviseur de code pour analyser les modifications apportées au code par rapport aux exigences avant de poursuivre. Elle doit être utilisée après avoir terminé des tâches, implémenté des fonctionnalités majeures, ou avant une fusion vers la branche principale. La revue aide à détecter précocement les problèmes en comparant l'implémentation actuelle avec le plan initial.
connect-mcp-server
DesignCette compétence fournit un guide complet permettant aux développeurs de connecter des serveurs MCP à Claude Code via les transports HTTP, stdio ou SSE. Elle couvre l'installation, la configuration, l'authentification et la sécurité pour intégrer des services externes tels que GitHub, Notion et des API personnalisées. Utilisez-la lors de la configuration d'intégrations MCP, de la configuration d'outils externes ou du travail avec le Protocole de Contexte de Modèle de Claude.
web-cli-teleport
DesignCette compétence aide les développeurs à choisir entre les interfaces Web et CLI de Claude Code en fonction de l'analyse des tâches, puis permet une téléportation transparente des sessions entre ces environnements. Elle optimise le flux de travail en gérant l'état et le contexte de la session lors du passage entre le web, la CLI ou le mobile. Utilisez-la pour des projets complexes nécessitant différents outils à diverses étapes.
