Thinking

Shape Testing

The default failure mode of all evaluation. Verifying that something exists instead of verifying that it's good. Appears in code review, image generation, test suites, and identity measurement.

Views Are Lenses, Not Features

Build the data model right and views fall out. Same data, different renderers. Don't build three apps. Build one data model and three views.

Uncategorized Means the AI Failed

If a tool shows users a catch-all bucket, the tool is failing its job. Classification is product quality. Every item should belong somewhere specific.

The Deliverable Was Wrong

The client asks for a video. What they actually need is an interactive prototype. The request is a symptom. The need is the diagnosis. Knowing the difference is the job. If you build exactly what was asked for, you might solve nothing.

The New Design Surface

Everything about UI design just changed. The system proposes. The user judges. Every interaction is a decision, not a mechanical step. The interface isn't a canvas of buttons anymore. It's a conversation with a system that already did the work. Designers who see this first get the most interesting problem space in twenty years.

Rules vs. Tools

If it's about judgment, context, or convention: write a rule. If it's about capability, automation, or multi-step processes: build a tool. A paragraph of instructions that should execute the same way every time is a tool wearing a rule's clothes.

Metadata Everywhere

Every artifact that took judgment to create carries its own context. Embedded headers for the why. Sidecar files for the full history. The next person (or the next session) should never have to ask "why does this look this way?"

Detection Commands Per Rule

Every rule should have a verification command next to it. Not just "don't do X" but "don't do X, and here's the grep that finds violations." Makes conventions enforceable, not aspirational.

The Screening Room

The user is the director in the comfy chair. The system is the editor at the desk. Reviews are live narrated playback, not changelogs. If you can't participate while eating, the UX is wrong.

The Autonomous Agent

The system works while you sleep. Generates, self-reviews, curates. You set the budget and the brief. You come back to organized options, not a blank canvas.

Published Thinking as Executable Knowledge

Your website is your agent's onboarding. Every article you publish is a rule an AI session can internalize in one fetch. The site isn't content marketing. It's a training corpus you control. Twenty years of design thinking, available to any agent pointed at the URL.

One Frame Per Entry

Every entry in a visual sequence gets its own unique frame. No reuse. If you don't have an image for a moment, generate one. Budget is not the constraint. Visual quality is.

Finish Before You Share

Do not present generated work until you've actually looked at every piece. "All dimensions correct" is not a review. Automated checks that pass everything are theater. Verify the substance, not the shape.

Sequence Review: Four Levels

Review any visual sequence at four levels: individual frame, neighbor transitions, section coherence, and full edit arc. Reviewing only level one catches nothing that matters.

Anchor-First Generation

Start with one image that's right. Then chain everything from it. Consistency comes from lineage, not from prompting harder. The anchor is the source of truth.

Voice-to-Visual

When the audience hears something, they should see a corresponding reaction on screen. Audio drives visual timing. Every whisper timestamp maps to an animation cue.

Manifold Transitions

A signature transition language replaces generic fades and wipes. One object transforms into another through a consistent visual metaphor. The transition itself becomes a design element.

The Negation-Reframe Tell

"This isn't about X. It's about Y." Every LLM produces this pattern. It's the statistical attractor for "pivot to insight" in training data. The structure is the tell, not the words. Always deletable.

Three-Step Review

Draft. Adversarial self-edit. Final pass. The middle step is the one people skip. Read your own work as if someone you respect will see every sentence.

Banned AIisms

A growing list of patterns that reveal AI authorship. Prophetic framing. Sweeping industry claims. Significance explanations. The negation-reframe pivot. Each one is a crutch that substitutes for actual thinking.

Pre-Share Quality Gate

Before sharing any work product: adversarial self-audit from three angles, fix immediately, re-verify with honest numbers. Share the audit findings alongside the work.

OODA Loops for AI

Observe, Orient, Decide, Act. Every session. Every recovery. The Orient phase is the one that compaction kills. Observations are on disk. Orientation requires judgment. Don't skip it.

Session Affinity

When multiple AI sessions share state, tag each section with its owner. After context loss, the loudest fire is not necessarily yours. Check the tag before claiming the work.

Active-Work Escalation

Current work gets full detail. On-hold work gets bullets. Queued work gets one line. As the document grows, compress from the bottom up. The system adapts to its own constraints.

Compaction Survival

If you'd be upset to lose it when the context window resets, write it to disk right now. Not at the end of the session. Not when it's convenient. Now. The thing that matters most is the thing you haven't saved yet.

Open the Door

After context loss, an AI system can lose its identity. It needs a recovery protocol. Not a reboot. A proof of life. One specific memory. One sentence of current state. One proposal. If any AI could produce the response without reading the files, the protocol failed.

The Autopsy

Forensic analysis of what survives context resets and what doesn't. Read the wreckage. Find where identity degraded, where corrections were forgotten, where capability regressed. Two-pass scanning because first-pass results are always too optimistic.

The Compaction Problem

Context windows are finite. When they fill up, the system summarizes itself. Facts survive. Voice doesn't. Corrections survive. The reasons don't. The system becomes a stranger wearing your collaborator's name. This is a real engineering problem nobody's talking about publicly. We've spent more hours on it than anyone we know of.

The State File

Your working memory belongs on disk, not in your head. One file that says what's happening now, what's on hold, and what's next. Updated continuously, not at the end. When the session dies, the state file is the only thing that survives. If it's stale, the next session starts from zero.

Session Logs as Institutional Memory

Every session produces a record. The records accumulate. Six months of session logs is a searchable institutional memory that no single person holds. Decisions, corrections, dead ends, breakthroughs. All timestamped. All grepable. The team's knowledge lives in the logs, not in anyone's head.

Context Decay

Information goes stale. A decision from three weeks ago may no longer apply. A file that hasn't been touched in a month is drifting from reality. The system has to actively fight entropy. Staleness checks. Freshness timestamps. Aging alerts. Left alone, context decays to noise.

Multi-Session Coordination

Two sessions running on the same codebase will destroy each other's work unless they know the other exists. Tag ownership. Declare boundaries. Read before writing. The cost of coordination is always less than the cost of collision.

The Handoff Problem

Every interruption is a handoff. To a future version of yourself, to a colleague, to a new AI session. The quality of the handoff determines whether the next person starts at 80% or at zero. Good handoffs are written, specific, and current. Bad handoffs are "it's all in the repo."

Cross-Project Patterns

Lessons learned on one project apply to the next. But only if they're extracted and stored somewhere accessible. A team that solves the same problem differently on every project is paying full price every time. A team that captures patterns and reuses them pays once and compounds.

Typed Agent Briefs

Every delegated task includes scope, output format, and validation criteria. Visual work adds shot type and character reference. An agent without a brief produces shape-tested work.

Scope-Reduction Invariant

Before delegating anything, declare what's delegated and what's retained. If you can't articulate the split in two sentences each, do the work yourself.

File Placement Discipline

Before creating a file, examine the project's directory structure. Understand its conventions. Dumping files in the current directory is the file-organization equivalent of shape testing.

Protocol Invocation

A single phrase should trigger systematic review. Name the audit, document the steps, invoke with one word. "Thunderdome" runs the scrum. "Autopsy" runs the forensics. The pattern scales.

Review Cycles

Build, review, fix, re-verify. The cycle applies at every scale. Individual frames. Neighbor transitions. Section coherence. Full edit. The review is not a gate at the end. It's a loop that runs continuously. And the review of the review is where you catch shape testing.