PowerUp Coaching — Living Knowledge Base

PowerUp AI Mastermind Recap — 2026-06-18

16 min read

PowerUp AI Mastermind — June 18, 2026

“The more thinking you do up front, the better the result downstream. That can take two hours — but the payoff is ridiculously huge. The PRD that comes out is bulletproof.” — Lou

This Week in 30 Seconds

  • Think before you spec — Lou’s biggest process change: before writing a PRD, run an adversarial, non-sycophantic tree-of-thought exploration of the whole solution. Don Back independently discovered the same move that morning. The shortcut (“just write the PRD”) makes the AI assume your idea is right and document it blind.
  • Effort can’t buy reasoning — Lou re-ran his Model Selection Playbook (Fable removed). Hard finding: you can’t crank a weaker model’s effort high enough to match a stronger one. Effort = depth of exploration, not reasoning power — and the extra loops often cost more than just using Opus.
  • Build agents as graphs, not pipelines — his agentic writing team runs on a telecom-style state machine: an editor receives every output, makes a reflective decision, and can route from step 6 back to step 3. Deterministic steps run as scripts; only judgment returns to the model.
  • Rewind, don’t re-correct — when the model misunderstands, don’t argue with it in-line (that leaves the bad answer in context). Rewind to your query, fix it, regenerate clean. Plus the fork-vs-rewind distinction and /btw side-chats.
  • Toward sovereignty — Lou is moving to make intelligence interchangeable (local + open-source models like Gemma/GLM) for independence, privacy (taxes), and cost — now that machines, open models, and portability have all matured enough.
  • The human stuff — Don Back: the clean structure you taught as best practice now reads as an AI tell. Donald: his “Sovereign Council” emails him morning and evening as an accountability coach in his own motivational voice. Dirk’s open-loops question surfaced Lou’s play-vs-outcome folder system.
  • Community wins — Donald launched his book and built his own reader for it; Bally is stepping back briefly to care for his mother; the Gears coaching cohort is greenlit at four (hoping for five).

1 — Claude Design: Worth Another Look?

Dirk opened with Claude’s Design surface popping into the desktop app. Bally has used it for “leaderized” branding assets and likes it (she also has Canva connected); Don Back’s read from chat: “a different application front-end into an Opus backend — the value is guiding people into better design than they’d manage on their own.” Lou tried it back in April (it’s been at claude.ai/design since then) for a Gears intake form and a slideshow and “didn’t see a major difference” from Opus 4.8, so he set it aside — but with Anthropic now pushing it into chat and co-work (labeled beta), the group agreed to play with it and bring back use cases. Elizabeth noted she saw no difference between Opus 4.8 high and max.

2 — The Here.now Work-in-Progress Tour

Lou walked the group through what he’s been quietly uploading to the temporary here.now site rather than dumping it all at once. Three pieces stood out:

  • Multi-Agent Context Manager (“one brain, many doors”) — a simple shared-context folder (just markdown files: current state, decisions, charter) that lets any CLI tool — Claude, Gemini, Codex, GLM, DeepSeek, open-source code — operate against the same project context. The point: run several CLI LLMs in different terminal tabs, each updating a common context so the next one picks up where the last left off, all billed to subscription rather than API. Survived a stress test.
  • Plugin marketplace distribution — treating the AIMM shared repo as a marketplace you install from, then pulling individual items into a project. The installed copy isn’t canonical (you don’t edit it in place), which sidesteps the symlink and duplication problems. Builds directly on Insight - Plugins Are How You Share Skills — Version-Controlled Capabilities From a Marketplace Repo.
  • Teaching blocks — three of them behind the context-manager work, plus the Contacts Manager plugin scaffold (downloadable as a zip) showing how to build and host your own marketplace.

3 — Effort Can’t Buy Reasoning

Lou re-ran his Model Selection Playbook with Fable removed to answer one question: can you raise a weaker model’s effort enough to match a stronger model’s reasoning? The chart says no. Effort controls how many times the model walks the decision/exploration tree before accepting an answer — depth, not reasoning power. Sonnet at max effort is still Sonnet. And the cost bites: a night of high-effort Sonnet coding “cost as much, if not more, than just using Opus,” blowing through his subscription plus $75 in overage.

The useful nuance is task-dependence: for coding, Sonnet is considerably weaker than Opus; for creative, advisory, and sales writing, Sonnet is much closer — “Sonnet High is fine for second-tier work, but Opus earns its flagship place. Anything with your name and face on it, stick with 4.7.” And don’t bother with Haiku Max where Sonnet Low would do — “Sonnet wins by a mile.” Related: he’s now baking the model + effort + spawn/fork decision into a skill’s front matter at authoring time, so no runtime inference is spent picking a model — pure signal-to-noise optimization.

💡 What This Means for You

Diagnose before you reach for the effort slider: is the model accepting a shallow answer (raise effort) or hitting its reasoning ceiling (switch models)? Reserve the flagship for code, deep strategy, and bylined work; let Sonnet carry everyday content.

Deep Dive: Insight - Effort Can’t Buy Reasoning — The Model Sets the Ceiling, Effort Sets the Depth

4 — Think in a Tree Before You Write the PRD

The spine of the session’s process teaching. Lou used to start a build by asking Claude to write the PRD. He realized that conversation’s only job was to produce the PRD — it assumed his idea was sound. So now he inserts a phase before it: “Be my adversarial, non-sycophantic brainstorming partner. Take me through the tree of thought — every branch, every problem, every blind spot — and don’t let us miss one.” Only after the tree is exhausted does he say “now write the PRD.” The result is “bulletproof.”

The validation was unplanned: Don Back had run the exact pattern that morning on a writing skill — exploring and debating before moving to a PRD, then to a skill — and reported “I like the output a lot better than going straight to a prompt. The depth of thinking really, really helps.” Kasimir tied it to the superpowers skill’s chained gates (brainstorm → plan → spec → implement, each confirmed before the next). Three independent arrivals at the same move.

💡 What This Means for You

Before you ask AI to write the plan, spec, PRD, or outline, run an adversarial tree-of-thought first. Walk every branch, prune the dead ends, defer the tangents — then synthesize. The thinking belongs before the spec, not during implementation.

Deep Dive: Insight - Explore the Whole Tree Before You Write the PRD · Tool: tree-of-thought-prep

5 — Managing Context: Rewind, Fork, Handoff, BTW

Dirk named the universal pain — half an hour in, Claude forgets how the conversation started. Lou’s toolkit:

  • Compact at ~100K tokens.
  • Handoff files — when a branch reaches a decision, have it write the decision + high-signal summary, then start a new chat from the handoff.
  • /btw — a side-chat with its own context for “I wonder how this works” detours, so you don’t pollute the main thread.
  • Spawn — push processing into a sub-agent and bring back only the result.
  • Rewind vs. fork — the sharpest distinction. Rewind replaces everything below your edit point in the same chat (the bad branch is gone). Fork preserves everything above and starts a new chat (the original stays intact). The habit that matters most: when the model gets it wrong, don’t correct it in-line — rewind to your query, add what it missed, regenerate. Otherwise the “shitty answers get into context and confuse the crap out of the model.”

This connects to the U-shaped memory curve (models remember the beginning and end of a conversation, forget the middle) and the limit on how many instructions they reliably follow.

💡 What This Means for You

Build the reflex: the moment an answer is off, rewind and re-ask — don’t type a correction. Your transcripts should stop containing “no, not like that” exchanges. Fork only when a wrong-for-now branch is worth keeping.

Deep Dive: Insight - Rewind, Don’t Re-Correct — Keep Failed Attempts Out of the Context Window

6 — The Writing Team as a State Machine (Graph, Not Pipeline)

Lou’s big current build — a model-effort-optimized agentic writing team, ~15 hours of work (a third yesterday, a third overnight while he slept, a third before the call). The architecture is the lesson: a state-event matrix borrowed from his real-time telecom days. An editor owns the flow; every sub-agent’s output returns to the editor, who makes a “stateful, reflective decision” and routes to whatever step is needed next — step 6 back to step 3, then forward again. The overall pipeline (research → angle → draft → revise → polish) is a backbone, but movement through it is a graph. New ideas that surface mid-stream go on a queue rather than being discarded to protect the pipeline. The editor never accepts the first response — each handoff is fine-tuned so the next step gets richer input.

Underneath: deterministic steps (JSON/Python plumbing, validation, merging) run as scripts on the machine; only thinking — reflect, categorize, draft, decide — returns to Claude, on subscription. Lou’s aim is to extract a general state-machine framework members can scaffold into any task: “you don’t need Hermes or OpenClaw — a simple implementation you control.”

💡 What This Means for You

Find the step in your AI workflow where a not-good-enough output got pushed forward anyway. That’s where you need a controller — one “editor” role that receives every intermediate result and decides accept / redo / re-route / queue before advancing.

Deep Dive: Insight - Build the Agent as a Graph, Not a Pipeline — The Editor-Led State Machine

7 — The GitHub Build Loop

Once the PRD exists, Lou turns it into GitHub work. “Go through this PRD and identify everything that could be a GitHub issue or feature” — each one done incrementally and in isolation. He creates a feature branch per issue (mostly for clean history; Git lets you revert anyway), implements one phase, then tests + lints before merging to main. He keeps it serial rather than parallel work-trees for now — overnight runs don’t need parallelism, and parallel merges add complexity. Notably, every code folder is a local Git repo he never pushes to a remote: he gets version control, rollback, and history without putting anything online. Model split: Opus 4.8 for architectural/PRD decisions and strategy at higher effort; lower effort (or experimenting with Sonnet) for the coding itself.

8 — Toward AI Sovereignty: Local and Open-Source Models

Prompted by Don’s question, Lou laid out why he’s moving toward local/open models. Three reasons stack: independence (“I feel vulnerable that every new AI means a massive change I have to make… I don’t want to be beholden to any frontier company”), privacy (doing his taxes, he scrubbed PII but still felt uneasy sending it to a frontier provider), and cost (he expects the next flagship to roughly double in price). Three forces have converged to make it viable: capable hardware (Gemma 4 runs near-frontier speed on his 24GB machine, using 3–4GB at a time via quantization + mixture-of-experts), capable open models (GLM, DeepSeek “almost at OpenAI level on some benchmarks”), and a mature, portable ecosystem.

The strategy isn’t “run everything locally” — it’s building harnesses that make the intelligence layer swappable: Ollama as a local gateway, or non-retaining pass-through hosts (Groq, OpenRouter) for confidential work. Honest caveat: at his $20-subscription volume the cost win is marginal — “the main benefit is the highest signal and context possible” — but “in production, all of these start to earn their keep.” (Kasimir noted the European wariness around Russia-linked sabotage when the conversation brushed geopolitics; the group moved on.)

💡 What This Means for You

Don’t migrate everything — make intelligence swappable. Route only genuinely confidential work (financials, client PII) to a model you control or a non-retaining host. Keep your skills and processes vendor-neutral so the harness owns your workflow, not the provider.

Deep Dive: Insight - AI Sovereignty — Build Interchangeable-Intelligence Harnesses So No Vendor Owns Your Workflow

9 — When Your Best-Practice Structure Becomes an AI Tell

Don Back surfaced a sharp content problem. He teaches a particular LinkedIn structure — clean transitions, airtight logic. He just read that this exact polish now reads as AI-generated, because “humans don’t write that perfectly.” The craft markers he taught as competence are now a detection signal. The recommendation he’s adopting: humanize it — conversational register, lived specifics, “things an AI couldn’t possibly know.” He’s mid-rebuild of the course (and cloning his voice in ElevenLabs to automate narration). The deeper lesson: a best practice is contingent on its environment, and the moment a structure becomes the default output of everyone’s tools, teaching it as a differentiator backfires.

💡 What This Means for You

Run an “AI tell” pass before publishing: what here could only come from a machine that’s read everything and lived nothing? Inject what it can’t — one specific thing that actually happened to you, an unhedged opinion, a conversational aside. Leave the human texture in.

Deep Dive: Insight - The Structure You Taught as Best Practice Is Now an AI Tell

10 — Donald’s Sovereign Council: An AI Accountability Coach

Donald shared a personal automation built on the same “council/board” pattern the group uses. His Sovereign Council emails him morning and evening to motivate him — briefed on his goals, his current work, and crucially the way he likes to be motivated (“like you’re selling me something, copy to myself”). It tracks the ironic gap between what he said he’d do and what he did, and nudges relentlessly. Two design choices make it work: a persona (a coach, not a reminder) and unflappable politeness — you can snap at it and it stays even, so it can’t be burned out the way a human accountability partner would. Implementation is modest: Claude generates the email from a brief, drops it in Google Drive, and a Google Apps Script watches the folder and sends it.

💡 What This Means for You

Brief an AI on your goals, current work, and the exact tone that moves you, and have it email you a morning “set the commitment” and an evening “did it happen?” Keep the persona deliberately polite — the value is a nudge you can’t exhaust or offend.

Deep Dive: Insight - Your AI Accountability Council — A Daily Coach That Nudges You in Your Own Voice

11 — Open Loops: Play vs. Outcome

Dirk asked the question every prolific tinkerer feels: how do you track the half-finished threads — the idea you chased mid-task, then lost the thread of why you started? Lou’s answer dissolves the guilt structurally. He separates play from obligation by folder: a code-experiments folder means “no output expected, this is play”; his AIM folder means “there’s an outcome and a deadline here.” When a shiny idea interrupts goal-work, he parks it as a new experiment in ten seconds and returns to the goal — experiments are “a way to find out where my priorities and passions are,” not debts. He names related chats so clusters become visible (a thread with seven forks signals “group these”), and when he truly loses track: “Claude, look over my last two weeks of conversations and tell me what I’ve been working on and where I’m at.”

💡 What This Means for You

Designate one space as play (no completion obligation) and another as outcomes (deadline attached). Park interrupting ideas in the play space and return to the goal. Once a week, have your AI report your open threads — promote what’s earned sustained interest, let the rest stay guilt-free.

Deep Dive: Insight - Separate Exploration From Obligation — Give Curiosity a Home So It Doesn’t Become Overwhelm

12 — Gears Coaching Cohort: Greenlit

Lou wrapped the Gears/Hub coaching cohort decision. With Donald, Elizabeth, Mazie, and (newly) one more, he has four — hoping for five but willing to run it. His honest frame: “It’s not about making money — it’s about getting all that good work out in the world and supporting you.” The plan: a last call for members, then next week walk the group through the Gears codebase, the following week the Hub/knowledge stuff, then live coding-process and go-to-market strategy “ad hoc, whatever you need.” Sessions will be recorded and consolidated into snippets, same as the mastermind.

Community Corner

  • Donald Kihenja launched his book (The 77 Day Protocol, on fasting) — and didn’t just publish it, he built his own reader for it (“I basically built my own Kindle”), magic-link sign-in and all. Also runs the Sovereign Council accountability automation.
  • Bally Binning is stepping back briefly to care for his elderly mother — “but I’m here.” He decided not to take the Gears coaching track for now.
  • Don Back is rebuilding a short course around humanized writing and cloning his voice in ElevenLabs.
  • Kasimir Hedstrom championed the superpowers skill — “lives up to its name” — for its chained brainstorm → plan → spec → implement gates.
  • Mazie Zdanowicz signed up for the Gears coaching (“I speak very sweetly to my AI 🤣”).

Try This Before Next Session

Before your next build (or course, offer, or plan), don’t ask AI to write the spec. First paste this and walk the whole tree:

“I have an idea: [describe it]. Don’t write a PRD yet. Be my adversarial, non-sycophantic stress-test partner — take me through a tree of thought, explore every branch, every problem, every blind spot, push back on anything that doesn’t hold up, and don’t let us miss one. Ask me one question at a time.”

When the tree is exhausted, say: “Now look back through our whole conversation and write the PRD.” Notice how much sturdier it is than what you’d have gotten by jumping straight to the spec.

Open Threads

  • State-machine framework — Lou wants to extract a general, scaffold-anywhere state machine from the writing-team build; still in progress.
  • Parallel work-trees — tried and shelved for now (merge complexity); serial overnight runs are fine for solo work.
  • Local-model memory — Lou’s next sovereignty question: which open-source memory solution to adopt (doesn’t want to reinvent it).
  • Plugin / invocation — getting installed plugin skills to surface under native / like first-class skills (carried from last week).
  • Gears cohort — last call out this week; first walkthrough next week.

Next session: 2026-06-25

← Previous

Derived Artifacts

Graph View

Backlinks