Macros Never Block Direct Ask

"A convenience that stands between you and the core is not a convenience. The direct question must always be one tap away."

The Core Path Is Sacred

The single most important thing Pippa Go does is let you ask Pippa a question. Macros are a lovely enhancement on top of that — reusable prompts, saved shortcuts — but they are strictly a layer above the core path, never a gate in front of it. You must always be able to open the app and ask a direct question without creating a macro, selecting a macro, syncing macros, or waiting for the macro list to load. If any macro-related step can ever stand between the user and a direct Ask, the enhancement has quietly become an obstacle.

Optional Means Optional, All the Way Down

"Optional" has to hold under every condition, not just the happy path:

Offline: can't reach the macro store? Direct Ask still works. Macros degrade; the core doesn't.
Empty: no macros created yet? Direct Ask works from the first launch. Macros are never a prerequisite.
Broken: macro sync errors, cache corrupt? Direct Ask is unaffected, because it never depended on the macro subsystem at all.

The test is simple and strict: could a failure anywhere in the macro system block a direct question? If yes, the layering is wrong. The core path must have zero hard dependencies on the convenience layer, so that convenience can fail in every possible way and the essential thing still works.

Enhancement Layers Point One Direction

This is the general shape of a healthy enhancement: it depends on the core, and the core depends on nothing above it. Dependencies point downward — macros reach down to the composer and the capture flow, and the composer knows nothing about macros. Get that direction right and you can add, change, or remove the entire macro system without touching the essential ask-a-question path. Get it backwards — let the core reach up into the convenience — and a wobble in the enhancement becomes an outage in the essential. Keep the arrows pointing the safe way, and 'optional' stays true no matter what breaks.

Code

Dependencies point downward: core knows nothing of macros·typescript

// The core ask path — no macro dependency anywhere in it.
async function askDirect(question: string, images: ResolvedImage[]) {
  const turn = createTurn(question, images.map(i => i.id));
  await commitLocally(turn);      // capture-first, always available
  return enqueueForDelivery(turn); // works offline, empty, or with macros broken
}

// The macro layer sits ABOVE and reaches DOWN into the core.
async function askViaMacro(macro: PromptMacro, input: string, images: ResolvedImage[]) {
  const question = compose(macro.instruction, input); // convenience on top
  return askDirect(question, images);                  // ...delegates to the core
}

// askDirect never imports or checks the macro subsystem.
// Macros can fail entirely and askDirect is completely unaffected.

Exercise

Pick an app with a 'convenience' feature layered on a core action (templates over compose, filters over a feed, presets over a control). Try to make the convenience fail — go offline, corrupt its state, empty it — and see whether the core action still works. If it breaks, the dependency points the wrong way. Sketch how you'd invert it so the core has zero dependency on the convenience.

Hint

The fix is always the same shape: the convenience layer imports and calls the core; the core imports nothing from the convenience. Then any failure in the convenience is contained above the core, and the essential action survives every way the enhancement can break.