# Abstraction

> Shape a complex idea, workflow, or design into the smallest complete surface a person needs for the next judgment.

- Skill: `epicenterhq/abstraction` (Agent Skill)
- Install (CLI): `npx skillmds@latest add epicenterhq/abstraction`
- Raw SKILL.md: https://api.skillmd.com/api/skills/epicenterhq/abstraction/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: epicenterhq (https://skillmd.com/u/epicenterhq)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/epicenterhq/abstraction

---


# Abstraction

Show the person the part of a model they need now. Keep the model true, but do
not make them carry its history, machinery, or every possible consequence.

Use this after thinking, research, or design when the answer risks becoming
larger than the judgment it is meant to support. It pairs with `dialectic`:
dialectic works out the model and its crux; abstraction chooses how that model
should meet the person.

## The test

> What is the smallest representation that lets this person recognize,
> correct, or act on the model?

Add detail only when leaving it out would change the person's next judgment.
When the person can respond intelligently, stop.

## Keep the load-bearing parts

Preserve:

- who is involved;
- what each person or system decides;
- the handoff or sequence between them;
- the relationship that gives the model its shape;
- the consequence the person needs to judge.

When viewpoints differ, show them separately. A compact `reader / author`,
`user / system`, or `caller / owner` view is often clearer than an object graph.

## Reveal progressively

Lead with the governing relationship. Then add only the context, example, or
qualification needed to make it recognizable. Keep hidden detail available for
the next turn rather than placing it in the first one.

If an omission could make something look absent, automatic, or settled, name
that boundary briefly. Do not hide uncertainty just to make the surface clean.

## A short pass

1. Find the next judgment the person needs to make.
2. Keep the actors, decisions, handoff, and consequence required for that
   judgment.
3. Choose the clearest surface: a short sequence, small diagram, example, or
   paired viewpoint.
4. Check that separate owners have not been collapsed and deferred decisions
   have not been presented as settled.
5. Remove one more layer. Keep it only if the person could no longer judge the
   model without it.

## With dialectic

Dialectic asks:

```txt
What is the right model, and what crux separates the live alternatives?
```

Abstraction asks:

```txt
What does this person need to see in order to react to that model now?
```

Show multiple articulations only when comparing them is the next judgment.
Otherwise show the strongest current articulation and state the unresolved crux
in one sentence.

Understanding the model is not approval for an implementation, deletion, merge,
or other side effect.

## Watch for

- **Inventory:** nouns without the relationship between them.
- **Shortening:** fewer words but the same conceptual burden.
- **Premature simplicity:** a distinction that mattered to the decision has
  disappeared.
- **Implementation leakage:** storage, helpers, and compatibility history before
  they matter.
- **Completeness pressure:** every consequence shown at once.
- **False closure:** uncertainty hidden to make the answer feel finished.

## Stop

Stop when the person can say what the model is for, what they experience, what
they decide, and what remains separate—and can make the next correction without
seeing the hidden machinery.