Grill AI to Align Before Coding in Smart Zone

LLM Constraints Demand Small, Resettable Tasks

LLMs operate in a 'smart zone' at conversation starts with fresh, unstrained attention mechanisms—optimal up to ~100k tokens regardless of model context limits. Beyond this, quadratic attention scaling (like adding teams to a football league) causes 'dumbing down,' leading to poor decisions. Familiar to most coders, this mirrors human overload.

LLMs also 'forget' like the Memento character: each session resets to a minimal system prompt (keep under a few thousand tokens; avoid bloating with 250k+). Sessions cycle through phases—system prompt → exploratory (codebase scanning via sub-agents) → implementation → testing/feedback. Clearing context returns to baseline reliably; compacting (summarizing history) adds unreliable 'sediment' that devs oddly prefer but speaker rejects for consistency.

Trade-offs: Long chats or multi-phase plans (common pre-2023) loop into dumb zone, burning tokens. Instead, break big tasks (e.g., cloning a company) into smart-zone chunks via loops or 'Ralph Wigum' (iterative small changes toward a PRD goal). Avoid AI companies' 'keep adding/compacting' cycle.

Quote: "Every time you add a token to an LLM, it's kind of like you're adding a team to a football league... scales quadratically."

Reject Specs-to-Code; Build Shared Design Concept

'Specs-to-code' (write doc, feed to AI, iterate specs if code fails) ignores code as the battleground—leads to 'vibe coding' misalignment. Instead, treat AI as pair-programming partner: relentlessly clarify to forge Frederick P. Brooks' 'design concept' (shared idea among collaborators).

Grill Me Skill (tiny prompt, repo-available):

Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies one by one. For each question, provide your recommended answer. Ask the questions one at a time.

Invoke via /grill me [client brief] after clearing context. AI explores codebase via sub-agent (isolated context, summarizes back—delegation pattern), then quizzes one-by-one with recommendations.

Process:

1. Feed brief (e.g., Slack msg: "Add gamification to course platform for retention—students drop after few lessons.").
2. AI probes: points economy (actions/amounts), retroactivity (backfill existing progress?), progression curves, UI placement, streaks.
3. Respond briefly (e.g., "Skip video watches—gameable; lessons core." Agree/skip recommendations).
4. Continues 40-100 questions, building alignment. Token count stays low (monitor via status line; article on AI Hero).

Use for client transcripts (e.g., feed Gemini meeting notes). Lasts 1hr+ but yields robust conversation history as design asset.

Common Mistakes: Eager planning without alignment (AI jumps to plan). Over-relying on frameworks (SpecIt, OpenSpec, Taskmaster)—own your stack for observability/fixability. Plan mode first? No—grill immediately.

Quote: "I needed to reach a shared understanding... on the same wavelength as the AI as my agent."

Hands-On: Gamification Feature from Brief to PRD

Exercise repo: Course CMS (Cadence). Client brief in clientbrief.mmd.

Alignment in Action (demo):

• Question: "Points economy? Rec: 2 sources—video watches, lessons."
  • Answer: Skip videos (noisy/gameable); lessons primary.
• "Retroactive? Existing timestamps."
  • No (avoids backfill complexity; vote in workshop: split).
• Levels curve, streaks standalone, UI in dashboard.

Sub-agent burns 93k tokens exploring but parent stays smart. Dictate responses for speed. Ends with aligned spec (e.g., points, badges, leaderboards implied).

Quality Criteria: Shared understanding (no assumptions); resolves dependencies sequentially; recommendations guide but you decide. Output: Grill history as PRD foundation—feeds implementation without specs-to-code loop.

Next: Build PRD, implement (workshop truncated). Fits broader workflow: Grill → PRD → small impl loops → test → clear/reset.

Pair Programming Analogy: Grill adds 'third person' quizzing like nav-driver in human pairing—effective for solo AI work.

Quote: "The code is your battleground... you need to keep a handle on the code. You need to understand what's in it."

Why Fundamentals Beat AI Hype

Software engineering basics (Martin Fowler's refactoring, Pragmatic Programmer: small tasks to avoid freak-out) apply directly—don't bite off more than chew. Multi-phase → loops → Ralph Wigum evolution shows iteration trumps paradigms.

Prerequisites: Basic AI coding (most attendees); repo cloning optional (Cursor/Claude). Intermediate devs; AI-curious.

Practice: Clone repo, invoke /grill me on brief. Extend to real projects/clients. Monitor tokens always.

Quote: "Software engineering fundamentals... also works super well with AI."

Key Takeaways

• Clear context often; prefer reset over compacting for reliable baseline.
• Keep system prompts tiny; monitor exact token count per session.
• Start every feature with /grill me [brief] for alignment—expect 40+ questions.
• Use sub-agents for exploration to preserve parent smart zone.
• Own your planning stack; avoid black-box frameworks until mature.
• Treat AI as pair programmer: shared design concept > specs.
• Break big tasks into ~100k-token chunks via loops/Ralph Wigum.
• Grill histories become PRDs; feed client transcripts for validation.
• Skip plan mode initially—grill first to prevent misalignment.