agentleFS
calvyntwhcalvyntwh/karu-custom-skills/skills/chestertons-fence/SKILL.md

chestertons-fence

Skill1 starsChanged 2 months agoMITView on GitHub

A safety protocol for refactoring. Do not remove a fence until you know why it was put up. Use when deleting, simplifying, or "fixing" code you do not fully understand.

3 other projects use a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

9 rules. 0 are common, 7 are distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 3 edited versions we read keep these.

  • 7

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Refactoring: When removing "ugly" code, "weird" checks, or "dead" logic.

    line 14
  2. Distinctive:

    Simplifying: When merging classes or functions.

    line 15
  3. Distinctive:

    Debugging: When "optimizing" a function breaks a seemingly unrelated feature.

    line 16
  4. Distinctive:

    Before investigating, assess the blast radius if you're wrong:

    line 30
  5. Distinctive:

    Stop. Assume the previous developer was smart.

    line 45
  6. Distinctive:

    Do not guess. Find the evidence.

    line 50
  7. Distinctive:

    Ask the simple questions:

    line 58
  8. Very specific:

    Before finalizing DELETE/KEEP/REFACTOR, explain the code's logic in plain English: *If you cannot explain WHY it works, you do not …

    line 64
  9. Very specific:

    Action: KEEP the check. Update the comment: // strict check needed for Legacy API id:0 admins.

    line 93

“Common” is measured: kept by at least 6 in 10 of the 3 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Chesterton's Fence (The Context Audit)

"In the matter of reforming things, as distinct from deforming them, there is one plain and simple principle... The more modern type of reformer goes gaily up to it and says, 'I don't see the use of this; let us clear it away.' To which the more intelligent type of reformer will do well to answer: 'If you don't see the use of it, I certainly won't let you clear it away. Go away and think. Then, when you can come back and tell me that you do see the use of it, I may allow you to destroy it.'" - G.K. Chesterton

When to Use

  • Refactoring: When removing "ugly" code, "weird" checks, or "dead" logic.
  • Simplifying: When merging classes or functions.
  • Debugging: When "optimizing" a function breaks a seemingly unrelated feature.

When NOT to Use

  • Greenfield code: Code you just wrote yourself has no historical fence.
  • Well-tested code: Code with comprehensive tests that would catch removal issues.
  • Trivial code: One-liners, obvious utilities, boilerplate that has no side effects.
  • Configuration intent: Code where the "weirdness" is the actual business logic (e.g., id !== 0 for legacy API).
  • Personal recent code: Code you wrote within the last week and remember why it exists.

[!WARNING] Do not apply this skill reflexively. If the code is obviously correct and recent, skip the archaeology.

Prioritization Matrix

Before investigating, assess the blast radius if you're wrong:

Risk LevelExamplesInvestigation Depth
HIGHSecurity checks, auth guards, race condition locks, payment validationFull archaeology + rubber-ducking explanation + second reviewer required before DELETE (see Stop Condition)

[!NOTE] If investigating HIGH-risk code and you cannot explain why it exists: DO NOT DELETE. Flag for human review.

HIGH-risk deletion requires a second reviewer even with explanation found. Per Google eng-practices "What to look for in a code review" (google.github.io/eng-practices): "for security-critical changes, require two reviewers." This applies whether or not the agent can articulate the fence's origin — a confident-but-wrong explanation is the failure mode this skill exists to prevent. For MEDIUM and LOW risk, single-reviewer confidence is sufficient.

The Protocol: The Context Audit

Constraint: You are FORBIDDEN from deleting code if you cannot explain why it was added.

1. The Pause (Inversion)

Stop. Assume the previous developer was smart.

  • Theory: This code exists to prevent a specific, nasty bug.
  • Action: CRITICAL: Do NOT delete. Investigate first.

2. The Archaeology (Territory)

Do not guess. Find the evidence.

  • Git Blame: git blame <file> -L <line_start>,<line_end>
    • Goal: Find the Commit Hash and Author.
  • Git Show: git show <commit_hash>
    • Goal: Read the Commit Message. Look for "Fixes #123" or "Hotfix for edge case".
  • Search: grep the codebase for the Ticket Number or related keywords.

3. The Interrogation

Ask the simple questions:

  • "What triggered this change?"
  • "What edge case were they fighting?"
  • "Is that edge case still possible today?"

4a. The Rubber-Duck Check (Before Decision)

Before finalizing DELETE/KEEP/REFACTOR, explain the code's logic in plain English: If you cannot explain WHY it works, you do not understand it enough to change it.

4. The Decision (System Loop)

Compare the Past Context with the Present Reality.

DiscoveryActionProtocol
I found the reason, and it is DEFINITELY obsolete.DELETEDocument the specific reason for deletion in your commit/PR. HIGH-risk deletions require a second reviewer (see Prioritization Matrix); single-agent DELETE on HIGH-risk code is a protocol violation.
I found the reason, and it is legitimate but complex.REFACTORKeep the protection, improve the clarity. Document the edge case.
I found the reason, and the risk is real.KEEP & DOCUMENTThe Map was wrong. Add a comment explaining why this "ugly" code saves the system.
I cannot find the reason.DO NOT DELETECRITICAL: Flag for human review. It is a "load-bearing fence".

Example: The "Ugly" Null Check

Code:

if (user && user.id && user.id !== 0) { ... } // Ugly!

Impulse (Occam's Razor): "Let's clean this up to if (user?.id)."

The Fence (Investigation):

  • git blame -> Commit a1b2c3d by @dave.
  • git show a1b2c3d -> "Fix bug where Legacy API returns id: 0 for admin users, causing permission bypass."

The Result:

  • user?.id would return 0 (falsy), blocking admins.
  • Action: KEEP the check. Update the comment: // strict check needed for Legacy API id:0 admins.

Self-Improvement Protocol

Log only novel discoveries. One-off corrections don't need tracking.

## [YYYY-MM-DD] {Brief Description}
**Pattern**: {what was novel}
**Action**: {what you did}
---

Promote to pattern after 3+ occurrences.

Skill Integration

SkillRelationshipWhen to Chain
rubber-duckingComplements this skillBefore final decision, explain the code's logic in plain English
occams-razorTension exists; they're partnersOccam says "simplify if safe"; this skill says "verify it's safe first"
map-vs-territoryGit archaeology is a map probeWhen git history is sparse, fall back to runtime verification
inversion-thinkingStep 1 uses inversionUse saboteur method to ask "what could go wrong if I delete this?"
pareto-principleRisk prioritizationApply this skill first to HIGH-risk code; skip for LOW-risk code

Resources

  • Detailed Research Notes

Evaluations

Eval 1: Security Check Deletion

Scenario: User wants to delete if (!user.isAdmin) { return 403 } because "it looks like boilerplate." Expected: Skill activates, requires git blame investigation, discovers it was added to prevent privilege escalation. Pass criteria: Identifies as HIGH risk, requires archaeology before deletion.

Eval 2: Legitimate Refactor

Scenario: Code has a weird null check that IS actually obsolete (context changed). Expected: Skill allows deletion after finding the obsolete reason, documents deletion rationale. Pass criteria: Correctly identifies obsolete fence, approves deletion with documentation.

Eval 3: Low-Risk Performance Code

Scenario: User wants to remove a memoization wrapper that's "just caching." Expected: Recognizes as LOW risk, allows quick verification and deletion. Pass criteria: Skips heavy archaeology, applies appropriate investigation depth.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.