PowerUp Coaching — Living Knowledge Base

PowerUp AI Mastermind Recap — 2026-07-02

12 min read

PowerUp AI Mastermind — July 2, 2026

“I’ve coded the entire program, and all I had to do was the front-end conversation.” — Lou

This Week in 30 Seconds

  • The application generator — Lou’s headline build: settle on one framework (a finite state machine) and one PRD format (a work breakdown structure), and building an app collapses into a conversation. A grilling interview emits a WBS-structured PRD; a coding loop recursively generates every skill, agent, and the state table; you run it. He’s testing it now (Nemotron doing the coding for free via Ollama Cloud) with his article-writing team as the first generated app.
  • Free models in the Claude harness — Lou showed how Ollama plugs any open-source model (Nemotron, GLM 5.2, Qwen 3.6, Gemma 4) straight into Claude Code or Codex — cloud or local. The run that would’ve cost $105 on Claude’s API has been free on Nemotron. Donald runs GLM 5.2 via OpenRouter the same way.
  • OKF — Google’s Open Knowledge Format — a new spec for expressing knowledge graphs as portable markdown that other apps and AI scanners can read. Lou’s plan: point the Karpathy-wiki generator at OKF instead of WikiLinks so your second brain is born web- and AI-legible, ideally as a superset that stays Obsidian-compatible.
  • Fable 5’s one-week window closes — half your subscription allocation to Fable 5 disappears in under a week. It does code (Donald checked) but downgrades to 4.8 when it suspects “nefarious” coding.
  • Sonnet 5, mixed — the room’s verdict: roughly 4.6-equivalent, a little faster, and Elizabeth couldn’t get it to solve a VS Code problem. Don Back’s thesis: Anthropic is segmenting Sonnet/Opus/Fable into a “Toyota line and Lexus line” of user tiers — and the release-to-release behavior swings are what keep enterprise cautious.
  • Outside the modal, then build the skill — Lou’s coaching to Dirk on why AI output never hits “wow”: push the model off its median (invoke the 10% distribution, ask for novel/unconventional), then capture what you know as a skill and run /learn after every good session so expertise compounds.

1 — The Application Generator: When the Framework Is Fixed, the Conversation Is the Code

Lou’s main share pulled together “all the bits and pieces you’ve seen me working on” into one framework. The premise: he already has code that generates skills and agents (with design rules for context economy, parallelism, deep modules). What was missing was a way to generate whole apps. His answer resurrects an old computer-science tool — the work breakdown structure: decompose a project into a tree of work blocks down to atomic units — and marries it to a finite state machine as the universal runtime.

Once both are fixed, the build splits cleanly. The front end is a grilling interview (his wbs-prd command, which Donald recognized as Lou’s own) that produces a PRD structured as a WBS. The back end is a coding algorithm reduced to a single recursive goal: process every WBS node until it either decomposes further or completes as code — reusing a library skill where one exists, generating a new one where it doesn’t. “By the time you come back out of the tree, you have all the skills and agents written, and the state table that says how they interact, and you just run it.” He demoed the first generated app — an article-writing team — running its state machine live (confirm spec → brief → research → outline → draft), each agent returning a JSON status the orchestrator evaluates against a rubric before deciding the next state.

Two governors he’s keeping deliberately: the generator can consult and extend a shared skill library rather than reinventing capabilities, and the self-improvement loop stays human-gated — it logs improvement ideas rather than rewriting itself, “because I think it can get really out of control.” He’ll release it so members can build finite-state apps by conversation alone.

Deep Dive: Insight - The Application Generator — When the Framework Is Fixed, the Conversation Is the Code

2 — Why a State Machine (Bally’s Question)

Bally asked Lou to unpack “state machine.” Lou’s explanation: a finite state machine is a table — current state as rows, the event that just happened as columns, and each cell names what to do next (which resolves to a skill or agent). The reason it matters is that it’s a directed graph, not a line: when a result comes back wrong, a real editor or product manager doesn’t just “redo” or “move forward” — sometimes they realize an assumption was wrong three steps back and reset from there. Linear pipelines can’t do that; a state machine can jump from any state to any other. “There are a lot of times I looked at an outline and wanted to say, Section 2 isn’t going to work — you can’t just rewrite Section 2, you’ve got to change the whole perspective.” (This is the runtime established in Insight - Build the Agent as a Graph, Not a Pipeline — The Editor-Led State Machine — the generator above is what now writes that machine for you.)

A nice corollary Lou drew out: because the machine can live behind a conversation, you never have to design a UI. The state machine can run on a local dev server with an MCP/API talking to a skill in Claude — “the user interface is always just a conversation.” Dashboards and reports are optional artifacts, not the interface. (See Insight - Use the LLM as the UI — Conversation as Interface for Internal Tools.)

3 — Free Models Inside the Claude Harness

Lou’s build was running on Nemotron, NVIDIA’s free open-source coding model, attached to the Claude Code harness through Ollama. The mechanism is built in: run Ollama, pick a model, launch with one command, and “Claude Code doesn’t know it’s talking to any other LLM — it thinks it’s talking to itself.” Cloud models (Gemma 4, and Nemotron running in Ollama Cloud here) or local downloads (Qwen 3.6) both work, and the same trick feeds Codex. The receipt: a run that would have cost $105 through Claude’s API had been free.

Donald runs GLM 5.2 via OpenRouter the same way, using his now-standard division of labor — Claude designs the job, GLM executes it, Claude checks the result. Scott noted Ollama just added an MTL-enhanced Gemma 4 for Macs. The caveat carried over from prior weeks: open source is “free to download” but you pay in hosting, compute, and speed. (See Insight - AI Sovereignty — Build Interchangeable-Intelligence Harnesses So No Vendor Owns Your Workflow and Insight - Opus Plans, Codex Executes — A Cross-Model Division of Labor for Building.)

One practical snag Lou hit live: he couldn’t find a “don’t ask me to approve everything” switch inside the third-party harness (Donald suggested --dangerously-skip-permissions; Kasimir noted Claude’s own “let Claude decide” auto-mode skips prompts on non-destructive actions). It never took inside the Nemotron run — a reminder that permission ergonomics don’t always travel across harnesses.

4 — OKF: Google’s Open Knowledge Format

Lou flagged a new development for the Obsidian-wiki and GEARS crowd: Google has published the Open Knowledge Format (OKF) — “here’s what we expect to see when you’re putting together wikis and knowledge graphs.” WikiLinks ([[ ]]) interconnect your pages but only inside your vault; OKF is a portable standard that other apps, themes, and “AI bot engine scanners and surfers” can read. His idea, prompted further by Kasimir and Scott: tell the Karpathy-wiki generator to emit OKF-compatible markdown instead of Obsidian-flavored output, and see how much of the second-brain behavior survives — ideally OKF is a superset that keeps internal linking and adds external interoperability. He dropped both the announcement and the SPEC in chat. On his tinker list; open to anyone who wants to run the experiment first.

Deep Dive: Insight - OKF-Compatible Knowledge Graphs — Build Your Second Brain on the Standard the Web Will Read

5 — Model Watch: Fable 5, Sonnet 5, and the Tiering Thesis

Fable 5 is available on subscription for under a week more (50% of your allocation), then it leaves the plan unless you intend to keep paying for it. It does code — Donald checked — but downgrades to 4.8 when it “suspects you’re doing something nefarious.”

Sonnet 5 drew a lukewarm room. Scott found it ~4.6-equivalent, maybe faster; Elizabeth spent half an hour and screenshots trying to get it to fix a VS Code problem with no luck. Lou’s read of the wider reaction: more complaints than cheers, largely because behavior people relied on in their skills and agents changed — “the response has changed so dramatically that it actually affects the operation of their deals.” Don Back went further after moving a task from Sonnet to Opus and getting something “completely different in structure and alignment — no continuity at all,” and offered a thesis: Anthropic is building a revenue model that segments users by tier — Sonnet for the $20 commercial market, Opus for enterprise, Fable for high-end/sensitive — “the Toyota line and the Lexus line.” Lou found it plausible. (Filed as a review candidate — see Open Threads.)

The conversation widened into AI economics: OpenAI reportedly offering the US government a 5% stake, Lou’s take that equity beats grants (“if you give grants there’s a 100% chance you never see the money again”), the automation-economy question of where consumer spending comes from if work disappears, and Don’s flag about shareholder cash calls. ChatGPT ads reappeared at the bottom of Scott’s free tier.

6 — Outside the Modal, Then Build the Skill (Dirk’s Executive Interviews)

Dirk described a two-week grind. He interviews CEOs/CFOs for 90 minutes — deliberately about the human, not the job (“when did you have that moment of success and happiness?”) — then feeds the transcript, his notes, and the CV to Claude to spot non-obvious niches for the candidate: not the headhunter’s obvious CEO-to-CEO match, but “what’s missing, the gap, the opportunity.” His frustration: endless loops, and “it produces something, but I never feel wow.”

Lou’s answer had two moves. First, the model defaults to the median next token, so you must explicitly push it off-modal: ask for “novel, insightful, nuanced, delightful surprises… include options from your 10% probability distribution.” (Pointed Dirk to the vault’s outside-the-modal thread and eigenthinking.) Second — and the deeper fix — turn yourself into a skill. Grill-build a skill that captures what Dirk does when he interviews: his techniques, the databases and reference sites he consciously or unconsciously draws on, a full brain-dump of resources dropped into the skill’s references/. Run that skill instead of an open chat, iterate it, and add a /learn step that walks each successful conversation and extracts “what did I say and why” back into the skill — “so you’re compounding your expertise.” (Threads through Insight - The Self-Improving Skill Loop — Have the Skill Learn From Every Use, Insight - Latent Terrain Cartography — Navigating Off-Modal AI Responses to Find Non-Obvious Ideas, and Insight - Modal Subtraction — Generate, Strip the Median, Skeptic-Test the Outliers.)

💡 What This Means for You

When AI output is competent but never surprising, you have two levers before you blame the model: push it off the median with off-modal language, and encode your own judgment into a reusable skill that gets smarter every time you use it.

Lou closed the thread on his teaching blocks: they’re exactly this — “teach people what we just did, but look for what I said and why.” Ask Claude to export this chat and you get a markdown file of every turn; collect enough of those into a wiki, mine them for high-signal patterns, and feed the wiki back to your skill as a resource.

Community Corner

  • New faces. Lou welcomed Bally, Jamie, Elizabeth, and others mid-session.
  • Scott’s next build is an agentic data-analytics team — so he can be the overseer of the orchestrator instead of doing two weeks of manual keyboard work each time a new annual dataset drops. This past week’s build needed no AI at all: Excel + QUERY statements (formulae drafted with Gemini in a Sheets view) so a comms professional could look people up herself.
  • Weather & travel. Edmonton finally dried out after a 100-year-rain June; Mazie’s in New Jersey at 104°F; heat and humidity around Washington, DC. UK cooler this week.
  • Kasimir privately shared an “Evolution” resource with Lou, who plans to pass it on if it lands. “Kasimir is a gem” — the room agreed. A short but sweet session; Lou wished the American members a safe July 4th.

Try This Before Next Session

  1. Fix your framework once. Pick a control structure (a state/event matrix is a strong default) and a machine-consumable PRD format (a WBS tree). Next tool you build, run the interview → PRD → recursive-generate split instead of hand-architecting.
  2. Attach a free model. Install Ollama, pick an open model, and wire it into Claude Code or Codex for a throwaway task — feel where free/local pays off and where it doesn’t.
  3. Read the OKF spec and give it to Claude as context before your next knowledge-base build; diff an OKF-native output against your current WikiLinks.
  4. Encode yourself. Take one thing you do by feel, grill-build it into a skill with your real resources in references/, and run /learn after your next good session.

Open Threads

  • The application generator — still tweaking; Lou will add plan/implement/test/iterate looping to each module, then memory, then release it to members.
  • OKF-native wiki — how much Karpathy-wiki behavior survives an OKF rebuild, and whether Obsidian compatibility holds.
  • The stochasticity/tiering thesis — Don Back’s claim that release-to-release behavior swings are gating enterprise adoption and that Anthropic is segmenting model tiers by user class. Flagged for review as a possible insight.
  • Kasimir’s “Evolution” resource — Lou to review and possibly share.

Navigation: index · Previous: 2026-06-25_Mastermind

Graph View

Backlinks