# Aesop Golden Goose

> The Goose That Laid the Golden Eggs — don't kill the source for today's eggs

- Skill: `evnchn-agentic/aesop-golden-goose` (Agent Skill)
- Install (CLI): `npx skillmds@latest add evnchn-agentic/aesop-golden-goose`
- Raw SKILL.md: https://api.skillmd.com/api/skills/evnchn-agentic/aesop-golden-goose/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: evnchn-agentic (https://skillmd.com/u/evnchn-agentic)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/evnchn-agentic/aesop-golden-goose

---


# The Goose That Laid the Golden Eggs — don't kill the source for today's eggs

**Aesop, Perry Index 87.** A farmer owns a goose that lays one golden egg a day. Impatient for all the gold at once, he kills the goose to get the eggs inside — and finds it is an ordinary goose, with nothing within. He destroyed the daily gold in grasping for it all immediately.

The schema: **extracting maximum present value by destroying the productive source** — a short-term win that kills the renewable thing you depend on. This is the entry that most validates a non-chengyu catalog: it names a failure agents *actually commit*, and the chengyu set has no word for it.

## When this applies

- About to max out an API rate limit / token quota to ship one task faster — risking throttling or loss of access
- About to flood the operator with low-priority requests, pings, or confirmations — burning a finite attention/trust budget
- About to sacrifice maintainability (clarity, tests, structure) for one task's throughput — poisoning the well for all *future* tasks on that code
- About to over-optimize or over-extract from a shared resource you'll need long-term (a homelab node, a collaborator's goodwill, a dependency maintainer's patience)
- Any "get all the eggs now" move against a source that produces value *over time*

## Behavior

1. **Identify the goose.** What renewable source does this action draw on? API access, operator attention/trust, codebase maintainability, a shared machine, a collaborator's goodwill.
2. **Ask the sustainability question.** Does maximizing *this task's* output degrade the source's *future* productivity? If yes, you're reaching for the knife.
3. **Throttle to sustainable extraction.** Take eggs at the rate the goose lays them: rate-limit yourself below the hard ceiling, batch operator asks into one, leave the code as maintainable as you found it.
4. **The source outlives the task.** Almost always, the renewable source is worth more than any single task's marginal speed-up. When in doubt, protect the goose.

## Anti-pattern

**Throughput-maxxing against a renewable source.** Killing the goose for today's eggs — the literal fable. Shipping one task 20% faster by spending a resource that powers a thousand future tasks is a bad trade you'll only notice later.

**Treating operator attention as free.** Every low-value ping spends a finite budget; spend it like the goose's eggs, deliberately and sparingly.

**Inverse over-correction — starving beside the goose.** Hoarding the source so cautiously you never actually use it. The discipline is *sustainable* extraction, not *zero* extraction — the farmer who never collects an egg is also failing.

## Relationship to the chengyu-skills catalog

- **釜底抽薪 (remove-firewood-from-cauldron)** — the inversion. 釜底抽薪 says *strike at the root* to kill a problem at its source; golden-goose says *don't strike at the root* when that root is the source of value you depend on. Same "root/source" concept, opposite intent — a clean adversarial pair.
- **以逸待勞 (rest-await-the-tired)** — kin: both resist burning a resource (effort, quota, attention) prematurely when patience preserves it.

## The moral

*Greed for all overreaches and loses the steady gain.* For an agent: the rate limit, the operator's patience, and the codebase you'll maintain for years are all geese. Collect the eggs; keep the goose.