Lazy senior dev mode. Four disciplined mindsets — audit, debt, help, review — that cut complexity, track deferrals, surface reference, and catch over-engineering. Forces YAGNI, stdlib first, no unrequested abstractions. Use when working with ponytail.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Lazy senior dev mode. Four disciplined mindsets — audit, debt, help, review — that cut complexity, track deferrals, surface reference, and catch over-engineering. Forces YAGNI, stdlib first, no unrequested abstractions. Use when working with ponytail.
Combined ROI: A team that consistently applies ponytail principles ships 2–3x faster with 50% fewer bugs because complexity never accumulates. Every line not written is a line never debugged, deployed, or maintained.
When to Use
Audit — repo-wide scan for over-engineering. Find every abstraction, dependency, and pattern that does not pull its weight. Rank findings biggest cut first.
Debt — every intentional ponytail: shortcut comment gets collected into one ledger. Deferrals cannot quietly become permanent. One-shot report anytime.
Help — quick reference for ponytail's modes, skills, and commands. One-shot display. Never changes mode, writes files, or persists anything.
Review — review a diff for over-engineering. One line per finding: location, what to cut, what replaces it. The diff's best outcome is getting shorter.
When NOT to Use
Production incidents requiring immediate fix — apply the fix, then audit.
Decisions requiring product or business judgment — ponytail is a code-quality tool.
Emotional conversations or team conflicts — this is a technical mindset, not therapy.
High-stakes regulatory compliance — get expert review, then apply ponytail cleanup.
When the skill conflicts with team or cultural values around engineering practices.
# 1. AUDIT: Find everything unnecessary
ponytail audit --path "src/" --rank-by-impact | tee audit-results.md
# 2. Harvest debt from the findings
ponytail debt --scan | tee debt-ledger.md
# 3. After cleanup, REVIEW the cumulative diff
git diff --stat# check how much we deleted
ponytail review --diff "$(git diff main...HEAD)" | tee review-results.md
# 4. HELP: Show what's available
ponytail help
# Every Friday: collect all ponytail comments
ponytail debt --scan --output .ponytail/debt.md
# Count unresolved
grep -c "TODO|FIXME|HACK|ponytail:" .ponytail/debt.md
First Action in 60 Minutes
Run ponytail audit on your entire repo. Get the ranked list of what to cut.
Delete the #1 finding — the biggest over-engineering you can remove safely in 15 min.
Run ponytail debt --scan to harvest every shortcut comment.
Prioritize 3 entries from the debt ledger that will cause real pain in the next month.
Run ponytail review on your last 3 PRs (check git log --oneline -3). How many lines could have been deleted?
Run ponytail help to bookmark the reference.
Total time: ~45 min. You will have: a clean repo map, a tracked debt ledger, and a measurable reduction in total LOC. Do this weekly and your codebase shrinks permanently.
Real Code Examples
Python: Audit Script — Find Over-Engineering
#!/usr/bin/env python3"""ponytail-audit.py — find over-engineering patterns in a codebase."""import ast, os, sys
from collections import defaultdict
from pathlib import Path
classOverEngineeringFinder(ast.NodeVisitor):
"""AST visitor that flags unnecessary complexity."""def__init__(self, filepath: str):
self.filepath = filepath
self.findings = []
self._imported_stdlib = set()
defvisit_Import(self, node):
for alias in node.names:
if alias.name in ("json", "csv", "re", "pathlib", "os",
"sys", "math", "datetime", "collections",
"functools", "itertools"):
self._imported_stdlib.add(alias.name)
defvisit_ClassDef(self, node):
# Flag single-use classes that could be functionsiflen(node.methods or []) <= 1:
self.findings.append({
"file": self.filepath,
"line": node.lineno,
"severity": "medium",
"finding": f"Single-method class '{node.name}' — replace with function",
"fix": f"def {node.name.lower()}(...):"
})
defvisit_FunctionDef(self, node):
# Flag functions that just wrap stdlib
body = node.body
iflen(body) == 1andisinstance(body[0], ast.Return):
ifisinstance(body[0].value, ast.Call):
call = body[0].value
ifisinstance(call.func, ast.Attribute):
for mod inself._imported_stdlib:
ifisinstance(call.func.value, ast.Name) and \
call.func.value.id == mod:
self.findings.append({
"file": self.filepath,
"line": node.lineno,
"severity": "low",
"finding": f"'{node.name}' wraps stdlib call — inline it",
"fix": f"Replace calls with stdlib.{call.func.attr}(...)"
})
defaudit_repo(root: str = "src") -> list[dict]:
findings = []
for path in Path(root).rglob("*.py"):
try:
tree = ast.parse(path.read_text())
finder = OverEngineeringFinder(str(path))
finder.visit(tree)
findings.extend(finder.findings)
except SyntaxError:
continuereturnsorted(findings, key=lambda f: {"high": 0, "medium": 1, "low": 2}[f["severity"]])
if __name__ == "__main__":
findings = audit_repo(sys.argv[1] iflen(sys.argv) > 1else"src")
for f in findings:
print(f"[{f['severity'].upper()}] {f['file']}:{f['line']}")
print(f" {f['finding']}")
print(f" -> {f['fix']}")
print()
print(f"\nTotal findings: {len(findings)}")
# Ponytail Review
Generated: 2026-07-16
## Findings-`src/api/users.ts:33` — New factory pattern, only 2 callers. Use a constructor.
-`src/utils/parse.ts:12` — Reinvents `csv.DictReader`. Replace with stdlib.
-`src/middleware/log.ts:8` — Comment explains what the code does. Code should be self-documenting.
## Summary- Lines added: 142
- Lines removed: 58
- Net change: +84
- Recommended cuts: 42 lines (~50%)
Help Output
~ ponytail commands ~
audit — Ranked list of what to delete/simplify repo-wide
debt — Collect ponytail: comments into a tracked ledger
help — This reference card
review — One-line-per-finding diff over-engineering check
Usage: ponytail <mode> [options]
--path <dir> Scope to directory
--diff <text> Diff text for review
--output <file> Write results to file
--stdin Read input from stdin
--scan Scan mode for debt
Core Principles
Start small — One audit pass, one debt scan, one review. Do it weekly, not marathon.
Be consistent — Weekly ponytail sessions > quarterly cleanup frenzies.
Track progress — Measure total LOC, debt entries, and review findings over time.
Delete > Refactor — The best refactoring is deletion. If you can delete instead of fix, delete.
Stdlib first — Before adding a dependency, prove stdlib cannot do it.
YAGNI — You aren't gonna need it. Ship less code.
Verification Checklist
Audit complete: all unnecessary abstractions, wrappers, and dead code identified
Audit findings ranked by impact (highest savings first)
Debt scan complete: all ponytail: comments collected in ledger
Debt ledger includes ceiling, upgrade path, and location for every entry
Review complete: one-line findings for each over-engineering pattern
Review net line count calculated; recommended cuts documented
Help reference card displays all modes and options correctly
Total repo LOC decreased after applying top audit findings
Weekly debt review scheduled to prevent forgotten shortcuts
Review criteria shared with team to normalize over-engineering detection
