Build Smarter, Not Harder with LLMs — Strategic Orchestration, Not Vibe Coding

![Building smarter, not harder with LLMs](/building_smarter_not_harder_with_llms/img/slide-01.png)

Note:
    Opening (deliver deliberately):
      - “Good afternoon everyone.” (Pause, smile, make eye contact with different sections.)
      - “I know it’s been a long day — second last talk before we head off.” (Light chuckle / empathy moment.)
      - “Yes, I did attend the vibe coding session this morning… and this talk is definitely *not* that.”
      - Contrast: Not about letting AI freestyle the codebase into oblivion; about building smarter, not harder.
      - Credit Harper Reed’s recent blog posts for inspiring the framing: shift from hand‑crafting every line toward orchestration + guardrails.
    
    Frame the through‑line: AI as collaborator → rapid planning loops → micro waterfall cycles → strategic engineer role → hyper‑defensive guardrails → enforceable standards.
    
    Engagement:
      - Ask: “Quick show of hands — who’s used AI to write *any* code in the last month?” 
      - React proportionally (if most: “Great, we’ll sharpen that workflow”; if few: “Perfect—this will accelerate your on‑ramp.”)

Transition to agenda.

## Agenda

<ul>
      <li class="fragment"><strong>Inspiration & shift</strong> (Harper Reed)</li>
      <li class="fragment">AI as collaborator (mindset)</li>
      <li class="fragment">Idea Honing → Spec → Blueprint</li>
      <li class="fragment">Micro waterfall & parallel agents</li>
      <li class="fragment">Guardrails: hyper‑defensive + standards</li>
      <li class="fragment">Strategic Engineer role</li>
      <li class="fragment">Real-world examples</li>
      <li class="fragment">Discussion / Q&A</li>
    </ul>

Note:
      Purpose: give audience mental roadmap of shift → workflow → safety → role → validation → interaction.
      
      - Inspiration & shift: credit Harper Reed; framing of rapid planning upfront replacing ad‑hoc hacking.
      - AI as collaborator: reject "vibe coding"; partnership & orchestration language.
      - Planning trio: Idea Honing (Q&A) → Spec (developer‑ready) → Blueprint (chunked prompt plan).
      - Micro waterfall & parallel agents: plan → build → review loops; concurrent feature/docs/tests agents = throughput.
      - Guardrails: hyper‑defensive habits (static analysis, selective formal verification, meaningful coverage, frequent commits, pruning noise) + AI‑readable standards (house rules loaded first).
      - Strategic Engineer: human moves to shaping prompts, tests, architecture, product alignment—enabled by guardrails.
      - Real-world examples: validation of the complete framework through concrete implementations.
      - Discussion / Q&A: invite workflows, bottlenecks, success/failure stories.
      
      Anchor line: “Fast code is useless without control.”
      
      Transition: Dive into Idea Honing to show first collaborative planning phase.

<img src="/building_smarter_not_harder_with_llms/img/slide-04.png" width="250px" alt="Human-AI loop" />

## AI as Collaborator

- Not just code gen 
    - Not "vibe coding" 
    - Structured partnership 
    - Iterative loop: Idea → Spec → Blueprint → Execute 
    - You: intent/tests • AI: accelerate/integrate

Note:
    Core message: AI shifts from tool to *active collaborator*; we orchestrate.
    
    Contrast first: not just firing prompts for blobs of code, not laissez‑faire "vibe coding".
    
    Define partnership cycle: you shape intent & constraints → AI proposes / implements → automated checks + you review → refine → next micro loop.
    
    Tie to loop: Idea Honing (Q&A) → Spec → Blueprint (prompt plan) → Execute (sequential code generation) → Review.
    
    Roles: Human = product sense, risk spotting, test design, architectural coherence. AI = rapid boilerplate + iterative change + parallel tasks (feature, docs, tests).
    
    Emphasize control: speed without drifting because planning & guardrails bound each loop.
    
    Transition: We'll zoom into Idea Honing next.

<img src="/building_smarter_not_harder_with_llms/img/slide-05.png" width="250px" alt="Loop" />

## Rapid Planning Loop

<ul>
      <li class="fragment">Idea Honing → Specification</li>
      <li class="fragment">Blueprint → Chunked Prompt Plan</li>
      <li class="fragment">Execute → Review (tests / refine)</li>
    </ul>

<span class="fragment">Full planning often in a few minutes.</span>

Note:
    - Idea Honing → Specification: one‑question‑at‑a‑time interrogation yields developer‑ready spec (requirements, architecture, data, errors, testing).
    - Blueprint → Prompt Plan: reasoning model (not code yet) breaks spec into safe, incremental, integrated steps; produces prompts + checklist.
    - Execute → Review: code‑gen model implements each prompt sequentially; automated tests + static analysis + human spot checks close the loop.
  
    Micro waterfall: distinct Plan / Build / Review phases but rapid, repeatable cycles.
  
    Concurrency hook: multiple agents can run off the same blueprint (feature, docs, tests) without losing coherence.

Emphasize speed: in a few minutes to go from raw idea to actionable blueprint enables live planning in meetings / pairing.

Transition: Next we show the prompts that drive specification & blueprint, then deep dive into Idea Honing mechanics.

Idea Honing Prompt

Ask me one question at a time so we can develop a thorough, step-by-step spec for this idea. Each question should build on my previous answers, and our end goal is to have a detailed specification I can hand off to a developer. Let’s do this iteratively and dig into every relevant detail. Remember, only one question at a time.

Here’s the idea:

<IDEA>

Specification Prompt

Now that we’ve wrapped up the brainstorming process, can you compile our findings into a comprehensive, developer-ready specification? Include all relevant requirements, architecture choices, data handling details, error handling strategies, and a testing plan so a developer can immediately begin implementation.

<img src="/building_smarter_not_harder_with_llms/img/slide-06.png" width="250" alt="Idea Q&A" />
    <h2>Idea Honing</h2>
        <ul>
        <li class="fragment">Describe idea; AI asks one question at a time</li>
        <li class="fragment">Outputs developer-ready specification</li>
        <li class="fragment">Requirements, architecture, data, errors, testing</li>
    </ul>

Note:
    Idea Honing:
      - We resist the urge to code; we *interrogate* the idea.
      - Prompt: AI asks exactly one clarifying question at a time – forces depth, prevents premature assumptions.
      - Outcome: a developer‑ready spec covering requirements, architecture choices, data handling, error strategy, testing plan.
      - Benefit: shifts human effort to judgement & completeness instead of manual boilerplate.
      - Emphasize: This Q&A loop is fast but exhaustive; creates shared mental model before a single line is generated.
    
    Segue: Once spec is stabilized, we hand it to a reasoning model for blueprinting.

Plan Prompt

Draft a detailed, step-by-step blueprint for building this project. Then, once you have a solid plan, break it down into small, iterative chunks that build on each other. Look at these chunks and then go another round to break it into small steps. Review the results and make sure that the steps are small enough to be implemented safely with strong testing, but big enough to move the project forward. Iterate until you feel that the steps are right sized for this project.

From here you should have the foundation to provide a series of prompts for a code-generation LLM that will implement each step in a test-driven manner. Prioritize best practices, incremental progress, and early testing, ensuring no big jumps in complexity at any stage. Make sure that each prompt builds on the previous prompts, and ends with wiring things together. There should be no hanging or orphaned code that isn't integrated into a previous step.

Make sure and separate each prompt section. Use markdown. Each prompt should be tagged as text using code tags. The goal is to output prompts, but context, etc is important as well.

<SPEC>

## Blueprint & Prompt Plan

<ul>
      <li class="fragment">Small, safe, iterative chunks</li>
      <li class="fragment">Clear prompts for code-gen</li>
      <li class="fragment">Reusable checklist</li>
    </ul>
  
    Note:
    Blueprint phase (full talk: "reasoning AI creates detailed blueprint"):
      - Use a *reasoning* model (not yet code‑gen) to transform spec into a staged implementation plan.
      - Criteria for each chunk: small enough for safe review + rollback; meaningful forward progress; test visibility early.
      - Instruct AI to *iterate* on chunk sizing (second pass to shrink/merge until right‑sized).
      - Deliverables: ordered list of steps, rationale per step, explicit prompts for code‑gen model, and a resumable checklist (state persistence across sessions / agents).
      - Benefit: eliminates big leaps; reduces orphaned code; supports concurrent agents (feature / docs / tests).
    
    Transition: Now, let's move to the "Micro Waterfall" approach—breaking down the plan into even smaller, sequential steps for implementation.

## Micro Waterfall

<ul>
      <li class="fragment">Plan → Build → Review (loop)</li>
      <li class="fragment">Parallel agents: features, docs, tests</li>
    </ul>
    
    Note:
    Micro Waterfall (from talk: “carefully defining a spec, generating the code, then reviewing it”):
      1. Plan (spec + blueprint) – deterministic scaffold.
      2. Build (code‑gen executes each prepared prompt sequentially).
      3. Review (tests + static analysis + human spot checks) → adjust → next loop.
    
    Feels iterative yet phases are intentionally *distinct* to reduce drift.
    
    Parallelism: spawn agents—feature implementation, documentation synthesis (implementation guide), test enhancement—driven off same plan → “concurrency on steroids”.
    
    Stress control: speed without losing architectural coherence or quality.
    
    Transition: This speed creates new risks. We need guardrails before we can safely operate at this velocity.

## Hyper-Defensive Coding

<ul>
      <li class="fragment">Static analysis</li>
      <li class="fragment">Formal verification</li>
      <li class="fragment">Extensive coverage</li>
    </ul>
 
    Note:
    Guardrails motivation (talk: “potential for quality to nosedive if left unchecked”):
      - Hyper‑defensive posture compensates for volume & speed of AI output.
      - Static analysis: immediate structural & type issues before runtime.
      - Formal verification (selective): critical paths / invariants (e.g., financial calc, auth flows) → mathematical assurance.
      - Extensive coverage: behavior net; focus on *meaningful* scenarios & edge boundaries, not trivial loops.
    
    Principle: assume AI will occasionally introduce subtle regressions; design systems to surface them fast.
    
    Transition: translate principles into daily habits.

## Practical Habits

<ul>
      <li class="fragment">Frequent commits (rollback points)</li>
      <li class="fragment">Prune pointless tests</li>
      <li class="fragment">Comprehensive documentation</li>
      <li class="fragment">Control through planning</li>
    </ul>
    
    Note:
    Practical habits (talk highlights):
      - Frequent commits: treat as checkpoints; rapid rollback when an agent “goes sideways”.
      - Prune pointless tests: AI loves to over‑generate trivial assertions; keep suite fast & signal‑rich.
      - Comprehensive documentation: generate implementation guides; feed back as context for subsequent agent passes (compounding clarity).
      - Control via planning: blueprint = change budget + alignment artifact; prevents getting “over your skis”.
      - Add: Use CI to auto‑enforce lint, type, test, security scans—bots gate bots.
    
    Segue: Beyond habits, encode standards so AI *starts* aligned.

## Rules for Humans & AI

<ul>
      <li class="fragment">Tech stack</li>
      <li class="fragment">Coding style</li>
      <li class="fragment">Testing approach</li>
      <li class="fragment">Run & test commands</li>
      <li class="fragment">CI/CD enforcement</li>
    </ul>
    
    Note:
    AI‑readable standards (talk section "Enforceable Project Standards"):
      - Purpose: living contract for humans + preloadable context for AI.
      - Contents: tech stack constraints; formatting & style conventions; testing philosophy (types of tests + coverage priorities); canonical run/build/test commands; security / error handling patterns.
      - Workflow: generate initial drafts *from* existing codebase → refine → store as discrete files (e.g., /docs/AI_GUIDELINES.md, /docs/TEST_STRATEGY.md).
      - Usage: inject into first prompt before any generation ("house rules").
      - Benefits: faster onboarding, reduced style drift, higher first‑try accuracy from models.
      - CI/CD Enforcement: integrate guidelines into CI to actively block divergence; prevents drift, speeds onboarding, aligns human + AI contributors through automated standards checking.
    
    Transition: With these guardrails in place, the human role fundamentally shifts to Strategic Engineer.

## Strategic Engineer

### From Code Craft → AI Orchestration

<ul>
    <li class="fragment">Shape prompts <span class="fragment fade-in-then-semi-out">→ distill intent & constraints</span></li>
    <li class="fragment">Define tests <span class="fragment fade-in-then-semi-out">→ codify expectations for self-verification</span></li>
    <li class="fragment">Maintain quality <span class="fragment fade-in-then-semi-out">→ enforce standards during velocity spikes</span></li>
    <li class="fragment">Handle edge cases <span class="fragment fade-in-then-semi-out">→ anticipate AI blind spots</span></li>
  </ul>

<div class="fragment">
    <br>
    <em>Flow ≠ hours of typing<br>
    Flow = steering multiple autonomous efforts</em>
  </div>
  
  Note:
  Role evolution (full talk: shift from “code as craft” / deep flow to orchestration):
    - Strategic Engineer is product manager + architect + quality assurance tester + developer more than just a prompt engineer.
    - Shaping prompts: distill intent & constraints; short precise prompts can outperform verbose walls.
    - Defining tests: codify expectations so AI can self‑verify (bots test their own output).
    - Maintaining quality: enforce structure, readability, performance, security hygiene while velocity spikes.
    - Handling edge cases: anticipate failure modes / data anomalies LLM may overlook.
  
    Mindset change: embrace context switching (AI working = your thinking window). Flow ≠ hours of typing; flow = steering multiple autonomous efforts.
  
  Audience prod: "Who still hand‑writes routine CRUD? What higher‑leverage activity could replace that time?"
  
  Transition: Now let's see this complete framework—process + guardrails + strategic role—in action through real examples

## Example: Stress Watch App

<ul>
      <li class="fragment">AI handled boilerplate & integrations</li>
      <li class="fragment">Focus on concept & testing</li>
      <li class="fragment">Idea validation through rapid prototyping</li>
    </ul>

Note:
    Framework validation through real implementation. This example shows the complete process + Strategic Engineer role + guardrails working together.
    
    Script: Watch app started with high-level idea; 15 min idea honing + spec + blueprint; AI generated project structure, dependencies, API scaffolding, integrations in hours instead of days. Strategic Engineer role: focused on product decisions, user flows, data validation, UI polish while AI handled boilerplate. Guardrails: mocks & stubs auto‑generated for tests; static analysis caught issues; standards maintained velocity. Result: acceleration of boring parts, energy invested in high-value decisions.

## Example: Client POC

<ul>
      <li class="fragment">Requirements captured</li>
      <li class="fragment">Working POC by meeting end</li>
    </ul>
 
    Note:
    Live demonstration of rapid planning + Strategic Engineer orchestration in real-time meeting context.
    
    Script: Client POC showing idea honing in real-time during meeting; asked targeted questions live, fed answers through process, AI compiled spec and generated working POC before meeting ended. Strategic Engineer role: conducting the process, managing quality, projecting results. Result: meeting energy shifted from speculative to collaborative with immediate feedback loop. Shows framework working under pressure with stakeholders watching.
    
    Transition: These examples validate the complete framework - rapid planning + strategic orchestration + quality guardrails working together to build smarter, not harder.

## Plan × AI × Guardrails

- Fast code is useless without control. 
    - Predictable, repeatable outcomes at scale 
    
    Note:
    Synthesis (talk conclusion themes):
      - Pillars: 
          - Detailed planning artifacts (spec + blueprint) 
          - Guardrails & defensive automation 
          - Enforceable standards
      - Core line: “Fast code is useless without control.”
      - Reframe AI: an “infinite junior engineer” executing well‑shaped intent; human value migrates to product resonance & strategic clarity.
      - Implication: differentiation shifts from elegance of handcrafted code to user impact & experience.
      - Encourage: treat each loop as a micro waterfall cycle—plan with precision, execute with leverage, review with rigor.
      - Set up final invite to discuss audience workflows & challenges adopting this.
    
    Transition: Open Q&A / discussion slide.

<h2>Discussion</h2>
    <h3>What is your workflow with LLMs?</h3>

<div class="countdown fragment" data-time="900"></div>
    
    Note:
    Closing script:
      - “So: a rapid ‘new waterfall’—spec → blueprint → code → review—on hyperdrive.”
      - “Our creativity isn’t diminished; it’s redirected to choosing *what* and *why*, not just *how*.”
      - Tie back to opening contrast (vibe coding vs strategic orchestration).
      - Prompt discussion: What parts of this loop are you already doing? Where does it break in your org (culture, tooling, trust)?
      - Invite sharing of successes / horror stories (AI regressions caught—or missed—by guardrails).
      - Thank audience sincerely; encourage experimentation with small internal pilot using standards + blueprint approach.
    
    End: “Thank you.”