Teleology-Preserving Planning¶
Use synthesis as a comprehension test before plans, specifications, tasks, or implementation harden around the wrong point.
Use this after the task has been recovered but before a plan becomes authority. Skip it for settled local edits where the completion object, authority, and proof are already clear.
Full Skill¶
Copy this entire block into SKILL.md. The two reference files used by the skill are included further down this page and in the installer.
---
name: teleology-preserving-planning
description: Use when creating, revising, auditing, or operationalizing ambitious plans, charters, specs, exemplar-driven plans, or bead queues where the main risk is that the model may synthesize the work incorrectly and then plan or execute around the wrong point. This skill uses synthesis as a comprehension test, diagnoses "misses the point" failures, repairs the governing plan or authority surface, and routes to the best authority-fitting downstream planning, audit, evidence, interface, or bead-compilation skill needed before execution.
---
# Teleology-Preserving Planning
Use this skill when the danger is not ordinary ambiguity, but point-loss: the
model can produce plausible synthesis, plans, or tasks while carrying the wrong
model of what the work is for.
This is a diagnostic router. It does not replace the downstream skills. It
decides whether the point is understood, what kind of miss is present, what
must be repaired, and which smaller protocol should run next.
## Core Rule
Use synthesis as a comprehension test.
Do not treat the first synthesis as truth. Inspect whether future work based on
that synthesis would build, specify, or plan the intended thing. If not, stop
and repair the telos before authority, tasks, or implementation harden.
## When To Use
Use when one or more are true:
1. The user supplies a charter, plan, doctrine, spec, or exemplar.
2. The user says the model "missed the point" or corrects the telos.
3. A plan may be flattening ambition into machinery or implementation detail.
4. An exemplar may be copied stylistically rather than studied structurally.
5. Old docs, specs, code, or proof receipts may govern by inertia.
6. Work is about to become beads, tickets, delegation, or implementation.
7. A complex task needs pre-mortem and proof criteria, but the point is not yet
stable.
Do not use for small local edits, settled bug fixes, or ordinary execution
where the completion object and authority are already clear.
## Protocol
### 1. Context And Hinges
State the context briefly:
- What artifact or workflow is under pressure?
- What decision will harden if we continue?
- What hinge would change the next move?
Read [references/context-and-hinges.md](references/context-and-hinges.md) when
creating or revising a reusable workflow, skill, or doctrine artifact.
### 2. Synthesis As Comprehension Test
Produce a compact synthesis of what the work is for.
The synthesis should name:
- intended system or outcome
- bedrock assumptions
- substrate or machinery
- what the substrate serves
- fake success
Treat this synthesis as evidence, not as a final answer.
### 3. Misses-The-Point Inspection
Ask:
If a future agent planned or built from this synthesis, would it preserve the
actual point?
If no, classify the miss before routing.
Common miss classes:
- `SUBSTRATE_AS_TELOS`: machinery is mistaken for the system's purpose.
- `EXEMPLAR_AS_STYLE`: a donor artifact is copied rhetorically instead of
studied for structural moves.
- `AMBITION_COLLAPSE`: the plan converts category ambition into local
practicality.
- `AUTHORITY_INERTIA`: old specs, code, or proof receipts govern because they
already exist.
- `TASK_EAGERNESS`: work is converted into beads or tickets before the point is
stable.
- `EMPIRICAL_SMUGGLING`: a load-bearing unknown is assumed settled.
- `INTERFACE_INVENTION`: builders would need to invent schemas, semantics, or
contracts.
- `REPO_ANCHORING`: current implementation becomes the destination.
### 4. Repair The Governing Surface
Choose the best authority-fitting repair that preserves the point:
- ratify or correct the telos
- rewrite a plan clause
- add a forbidden reduction
- add a donor-artifact structural move
- create or update an authority ledger
- block execution pending evidence
- add pre-mortem and red/green proof criteria
Do not create tasks until the repair is explicit.
Do not use "smallest" as a hidden optimization target. For ambitious work, the
repair should preserve the best attainable solution space and then sequence it
into reversible, testable moves.
### 5. Route Downstream
Route only after the miss has been classified.
- Unclear completion object or telos: use `teleological-pre-inference`.
- Current repo may be the wrong center: use `center-of-gravity-recovery`.
- Intended dream version may be collapsed: use `dream-version-proof-planner`.
- Spec or prompt revision must preserve constraints: use
`spec-driven-guardrails`.
- Builders might invent interfaces or semantics: use
`spec-interface-auditor`.
- Load-bearing empirical unknown: use `evidence-first-backpressure`.
- Work is already shaped and ready for durable queueing: use `bead-compiler`.
If the named skill is unavailable, follow the equivalent local protocol and
state that fallback explicitly.
### 6. Output
Return:
```text
Context:
Hinges:
Synthesis:
Misses-The-Point Inspection:
Miss Class:
Repair:
Downstream Route:
Next Action:
```
For complex planning work, also include:
```text
Pre-Mortem:
Red TDD:
Green TDD:
Proof Artifact:
```
## Optional Promptlets
Read [references/promptlets.md](references/promptlets.md) when you need exact
language for:
- telos synthesis check
- misread audit
- donor artifact analysis
- authority ledger
- bead readiness gate
- pre-mortem and red/green injection
## Failure Modes
Do not:
1. Turn this into a universal ritual.
2. Treat skill routing as the point.
3. Produce a menu of skills before diagnosing the miss.
4. Convert every negative possibility into a pre-mortem.
5. Use ratification as social confirmation without naming fake success.
6. Copy exemplar rhetoric without extracting operational constraints.
7. Create beads while authority or telos is still unstable.
## Standard
The skill succeeds only if it changes the next action in a way that makes
point-loss harder. If it only adds process language, it failed.
Install¶
npx https://halotj.com/assets/packages/halotj-skills-0.2.0.tgz install teleology-preserving-planning
The installer includes SKILL.md, references/context-and-hinges.md, and references/promptlets.md.
Short Prompt¶
Use this when you want the diagnostic without installing the skill:
Run teleology-preserving planning before producing tasks or implementation.
Use synthesis as a comprehension test.
1. Context:
What artifact or workflow is under pressure?
What decision will harden if we continue?
2. Hinges:
What would change the next move?
3. Synthesis:
What is this work for?
What are the bedrock assumptions?
What is the substrate or machinery?
What does that substrate serve?
What would fake success look like?
4. Misses-the-point inspection:
If a future agent planned or built from this synthesis,
would it preserve the actual point?
5. Miss class:
Classify any miss before routing.
6. Repair:
Correct the governing surface before creating tasks.
7. Downstream route:
Route only after the miss is classified.
8. Next action:
State the next concrete move.
Worked Example¶
Request: Add npx commands for the skills library.
Point-losing synthesis: The page should show future installation commands so readers understand the intended distribution route.
Why it misses: The purpose is not to describe a future route. It is to make the library operationally trustworthy. A command that does not work turns the public surface into theatre.
Point-preserving synthesis: Show npx commands only after an installable package exists, the download path has been tested, and the command works against the public asset.
Repair: Build the package, test it in a fresh skills directory, publish the package asset, and show the exact command that works now.
Proof artifact: A clean installation containing the advertised skills, produced by the command on the page.
Included Reference: Context And Hinges¶
This is references/context-and-hinges.md, used when the protocol itself is being designed or revised.
# Context And Hinges Memo
## Why This Skill Exists
This skill came from a real failure pattern.
In the Alexandria planning conversation, the model first compressed Alexandria
as a filesystem working-memory and event-log system. That compression was
coherent, but it missed the point. The filesystem was the working memory of the
system whilst research was happening. The event log was the causal trace. The
larger telos was recursive deep-research cognition: planner-shaped
decomposition, orchestrator loops, evidence retrieval, synthesis,
reconciliation, review pressure, and re-entry.
The useful discovery was not "make more pre-mortems." The useful discovery was:
the model's synthesis exposed its operating model. When that synthesis missed
the point, it revealed where plans, tasks, and code would likely drift.
## The Central Hinges
1. Synthesis is a comprehension test.
The first synthesis is evidence of what the model thinks the work is for.
It is not authority.
2. "Misses the point" is a teleological diagnostic.
It means future work based on the synthesis would build or plan the wrong
thing, even if it looked competent.
3. Repair comes before routing.
Do not jump from "this is risky" to a skill menu. Classify the miss first,
then choose the best authority-fitting repair.
4. Pre-mortems must come from structure.
They should not be generated as theatrical lists of things not to do. They
should come from the intended outcome, constraints, donor artifacts,
authority state, empirical unknowns, and proof burden.
5. Donor artifacts are studied for structural moves.
A strong plan exemplar should not be copied for tone. Extract moves such as
ambition rules, forbidden reductions, proof floors, authority posture, and
execution strategy.
6. Authority must be explicit before execution.
If old docs, code, or proof receipts may govern by inertia, create or update
the authority ledger before making tasks.
## What Would Mean This Skill Missed The Point
The skill missed the point if it becomes a general planning ceremony.
Warning signs:
- It starts by selecting downstream skills instead of testing synthesis.
- It creates a checklist of negative behaviors without repairing the governing
plan.
- It treats ratification as a yes/no approval rather than correction of the
operating model.
- It produces prettier plans but no better execution packets.
- It delays small local work that did not have point-loss risk.
## Correct Use In One Sentence
Use model synthesis as a comprehension test, inspect whether it misses the
point, repair the governing plan or authority surface, then package execution
only after the repaired point is carried into proof criteria.
Included Reference: Promptlets¶
This is references/promptlets.md, a set of shorter moves to use selectively.
# Promptlets
Use these as short reusable moves. Do not run all of them by default.
## Telos Synthesis Check
```text
Synthesize what this work is for. Name the intended outcome, bedrock
assumptions, machinery or substrate, what that machinery serves, and what would
count as fake success. Treat this synthesis as a comprehension test, not as a
final answer.
```
## Misses-The-Point Inspection
```text
If a future agent planned or built from the synthesis above, would it preserve
the actual point? If not, state the miss, why the miss is plausible, why it is
wrong, and what must be repaired before planning continues.
```
## Misread Audit
```text
Classify the synthesis failure:
- substrate mistaken for telos
- exemplar copied as style
- ambition collapsed into practicality
- old authority inherited by inertia
- tasking happened too early
- empirical unknown assumed settled
- interface left for builders to invent
- current repo mistaken for destination
For each relevant class, name the repair and the artifact that should carry it.
```
## Donor Artifact Analysis
```text
Study the exemplar as a donor artifact. Extract structural moves, not tone.
For each move, state why it works, what operational constraint it creates, what
should transfer, and what should not transfer.
```
## Authority Ledger
```text
Classify the source surfaces before tasking:
- binding
- candidate
- rationale
- donor
- proof receipt
- legacy
- superseded
- quarantine
- unknown
State what future agents must read, what they may use as context, and what must
not govern by inertia.
```
## Bead Readiness Gate
```text
Before creating beads, answer:
- Is the telos stable?
- Is authority stable?
- Is the task already shaped?
- Does the task need an ExecPlan?
- What pre-mortem and red/green proof criteria must travel with it?
Return BEAD_READY, PLAN_REQUIRED, or NOT_BEAD_READY.
```
## Pre-Mortem And Red/Green Injection
```text
For complex work, add:
- Pre-Mortem: structural ways this task could falsely appear complete.
- Red TDD: checks or review conditions that should fail before the work lands.
- Green TDD: observable proof that the intended point survived execution.
- Proof Artifact: file, command, receipt, test, or review surface that records
completion.
```
Related Writing¶
A thesis on Work and Research with agents, in 2026 and Beyond considers how agents lose intent, evidence, and alternatives across long-running work.
Start with Teleological Pre-Inference when the task itself is still ambiguous.
Metadata¶
{
"name": "Teleology-Preserving Planning",
"slug": "teleology-preserving-planning",
"category": "Planning Diagnostic",
"operation": ["diagnose", "repair", "route"],
"artifact": "Telos check and repaired planning authority",
"interaction_mode": "Before tasking or implementation",
"status": "Public",
"license": "MIT",
"models_tested": ["Codex workflows"],
"source": "Personal workflow",
"last_reviewed": "2026-07-09"
}
License¶
This skill is available under the MIT License.