C.W.K.
Stream
Lesson 04 of 04 · published

Say No to the Second Brain

~11 min · stay-thin, non-goals, no-second-brain, discipline

Level 0Cold Flint
0 XP0/34 lessons0/12 achievements
0/100 XP to next level100 XP to go0% complete
"Every heavy app was once a thin one that kept saying yes to reasonable additions."

Thin Clients Drift Heavy

A thin client does not stay thin on its own. It drifts heavy, one sensible feature at a time, because every step toward a second brain sounds like an improvement in the moment. The discipline of Flint is not that these temptations never appear — they always do — but that the app is built to keep refusing them. Staying thin is an active practice, not a starting condition you can coast on.

The Reasonable-Sounding Ways In

Watch how the drift argues for itself. 'The model call is slow; let's cache the result here.' Now Flint holds state it has to invalidate. 'Let's remember the last few transformations for context.' Now Flint has a conversation history. 'Let's give Flint its own little persona so it feels consistent.' Now Flint has an identity. 'Let's bundle a tiny local model so it works when the brain is down.' Now Flint has a model runtime. Each is reasonable; together they are the exact machinery the remake deleted, rebuilt one yes at a time.

THE NON-GOALS (each one a 'no' Flint keeps saying)
--------------------------------------------------
no model runtime            no conversation history
no web UI                   no vault reader of its own
no HTTP server / port       no parallel Pippa identity
no model caching            no shared macro CRUD with the brain

Every item is a thing that would have made Flint heavier and
a thing the brain already owns. The list is the spine.

The Non-Goals Are the Spine

This is why Flint keeps an explicit list of things it will not become. A non-goal list isn't negativity; it's structure. When a change request arrives — 'can Flint just cache this?' — you don't re-litigate the whole philosophy, you check the list: caching a model result means holding and invalidating state, which is the model-runtime drift, which is a non-goal. The list turns a hundred future arguments into one lookup. It's the load-bearing wall you don't move.

A borrowed capability must not be re-grown in the borrower. When you depend on another system for a capability, the discipline is to depend on it fully — not to keep a small local copy 'just for convenience' or 'just for offline.' Each partial re-implementation is a second source of truth that will drift from the first. Borrow completely, or own completely; the half-and-half is where the heaviness and the bugs both live.
The yes that's hardest to refuse is 'just cache it.' It feels free — one dictionary, a little speed. But a cache is state, and state is the first cell of a brain. Dad's rule for the family is that the client stays a pair of hands: it can be smart about macOS, focus, and safety, but it must stay dumb about language and memory. The moment Flint remembers what it transformed, it has started becoming the thing it was built to not be.

Code

Staying thin is a background agent, not a full app·swift
// Flint runs as a menu-bar agent (LSUIElement), not a windowed app with
// a dock icon and a life of its own. That posture IS the thinness:
//
//   Info.plist:  LSUIElement = true      // background agent, no dock
//
// It has a small settings window for editing macros, and otherwise it
// waits, acts, and disappears. No server to run, no session to keep,
// no model to load. The shape of the process enforces the boundary:
// there is nowhere for a second brain to live.

External links

Exercise

For each of these feature requests, decide whether it keeps Flint thin or starts growing a second brain, and name the non-goal it touches: (a) cache the last result to re-show instantly, (b) add an undo of the last transformation, (c) bundle a fallback model for when the brain is offline, (d) let the user reorder their local macros. Where exactly is the line between 'smart about macOS' and 'smart about language'?
Hint
(a) grows a brain — it's held state that must be invalidated (model-caching non-goal). (b) is fine — undo is a macOS/insertion concern, not language memory. (c) grows a brain outright — a model runtime non-goal. (d) is fine — local macro CRUD is squarely Flint's own. The line is exactly there: capabilities about focus, pasteboards, keys, and safety are Flint's to hold; capabilities about meaning, memory, and models belong to the borrowed brain.

Progress

Progress is local-only — sign in to sync across devices.
Spotted a bug or have feedback on this page?Report an Issue

Comments 0

🔔 Reply notifications (sign in)
Sign inPlease sign in to comment.

No comments yet — be the first.