failure-archaeology

Record past investigation outcomes to prevent re-proposing rejected fixes.

2|3|Updated Nov 28, 2025
One-click install
npx skills add https://github.com/richardthe3rd/cambridge-beer-festival-app --skill failure-archaeology
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: failure-archaeology
Source: https://github.com/richardthe3rd/cambridge-beer-festival-app/tree/main/.claude/skills/failure-archaeology
Command: npx skills add https://github.com/richardthe3rd/cambridge-beer-festival-app --skill failure-archaeology

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common problem of teams wasting time re-investigating already-solved design decisions, re-proposing fixes that were previously rejected, or re-breaking hardened code because they lack context on past investigations, ADR rulings, and dead-end experiments.

Core Features & Use Cases

  • Structured investigation records: Each entry follows a strict Symptom → Root cause → Evidence → Status → Lesson format, with cited PRs, issues, and file locations for full traceability.
  • Rejected alternative tracking: Explicitly lists dead-end solutions and rejected fixes with their rationale, so developers and automated reviewers don't re-propose known-bad approaches.
  • ADR and cross-skill integration: Includes alternatives tables from architecture decision records and cross-references to related skills (e.g., diagnostics-and-tooling, api-contract) for full context.
  • Use Case: Before proposing a change to the app's state management, caching, or routing logic, use this Skill to check if the fix was already tried, if an ADR covers the decision, or if there are existing guardrails you might break.

Quick Start

Consult the failure-archaeology skill to review past investigation outcomes before proposing a new fix to the app's connectivity error handling logic.

Frequently Asked Questions about failure-archaeology

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I check if a code fix was already rejected in a previous technical debt investigation?

To check if a code fix was already rejected, you can review structured investigation records that document past root causes, evidence, and the rationale for dead-end solutions. This prevents re-proposing known-bad approaches during code review and bug triage workflows.

What is the best way to stop developers from re-fighting settled architecture decisions in code review?

The best way to stop re-fighting settled architecture decisions is to consult historical decision records that cite ADR rulings and rejected alternatives. This provides immediate context on past investigations, stopping redundant proposals and preventing the regression of hardened code.

How do I track rejected alternatives and dead-end solutions in my repository?

You track rejected alternatives by maintaining structured historical records that explicitly list dead-end solutions alongside their rejection rationale, cited PRs, and issue locations. This ensures automated reviewers and developers do not re-investigate previously failed state management or routing fixes.

Can I use ADR references to prevent breaking guardrails during state management or caching changes?

Yes, you can use ADR references to prevent breaking guardrails during state management or caching changes. Cross-referencing architecture decision records provides full context on existing guardrails and past connectivity error handling logic before you propose a new fix.

Why does my team keep re-investigating the same bug triage and API design decisions?

Your team keeps re-investigating the same bug triage and API design decisions because they lack structured historical records of past investigations. Without cited evidence and rejected alternative rationales, developers waste time re-breaking hardened code and re-proposing known-bad approaches.

When should I review past failure analysis records before proposing CI or routing logic changes?

You should review past failure analysis records before proposing any CI or routing logic changes to ensure you do not break existing guardrails. Checking previous investigation outcomes prevents redundant re-investigation of already-settled design decisions and dead-end experiments.