Application work pays once; agentic work compounds across every future task — so when you must choose, fund the layer that multiplies work over the layer that produces it.

Principle

Prioritize Agentics

The core asymmetry

Additive returns stack. Multiplicative returns compound.

Application layer

+1

Pays once

schema · routes

components · logic

Additive. One feature, one improvement, one bug fix. Each investment removes friction from one thing.

Agentic layer

×N

Pays forever

.claude/ · CLAUDE.md

skills · hooks · ADWs

Multiplicative. One skill correction applies to every agent run — this session, the next 100, every future contributor.

Over a long-enough project, the agentic investment is worth more than any individual application improvement — by a large margin.

If you don't price the compounding, you will always default to the application layer — it feels more like shipping.

Six months on the same codebase

The divergence is not linear.

Two engineers. Same project. Different allocations.

highoutputlowABm1m3m6

Engineer A80 app / 20 agentic

Engineer B40 app / 60 agentic

Month 1

Aships fast

Bslower start

Month 3

Are-explaining patterns

BADW runs the pipeline

Month 6

Aquality drift accrues

Bships with minimal presence

Each agentic improvement removes friction from every future task. Each application improvement removes friction from one.

The operating rule

Done it manually twice? Encode it.

First time reveals the pattern. Second time confirms it's a class.

Explained a process to an agent twice

→

write a Skill

Fixed the same class of error twice

→

write / update a Hook

Orchestrated the same workflow twice

→

write an ADW Script

Manually fired an agent for the same condition twice

→

write a Trigger

After the second occurrence, every future repetition is a debt payment with interest.

Encoding it is the system fix. Not encoding it is the individual fix that leaves the system capable of the same failure indefinitely.

"Twice" is the threshold because once is coincidence — twice is a class. After that, not encoding is a choice.

How to spot a project that's violating this

Four symptoms that appear together.

✗ Agents rediscovering context

The same architectural decision explained three sessions in a row. No Mental Model, no updated CLAUDE.md. Every session pays the cold-start tax.

✗ Manual rework cycles

The same class of agent error — phantom edit, wrong import, off-idiom test — fixed by hand each time. No hook exists to catch it. The system remains capable of the error.

✗ ADWs that go stale

Scripts written in month one reflect month-one code. Six months later they run outdated workflows. The agentic layer falls behind the application it was meant to govern.

✗ Lopsided quality

Lint rules, typed schemas, clean boundaries in the app. The .claude/ directory has a two-line CLAUDE.md. The gap reveals the investment imbalance.

The diagnostic question

"If I handed this project to a fresh agent with no history — how much would it have to rediscover?"

The answer measures the depth of your agentic layer. High rediscovery cost = you violated the principle. Low rediscovery cost = the harness carries the knowledge forward.

The application ships a version. The agentic layer compounds across all of them — which means it is never finished.

The discipline

The agentic layer gets the first dollar, not the last one.

Build the system that builds the system. Every improvement to the intelligence layer compounds across every future issue it touches — so invest there first, continuously, and before the application feels "done."