Harper Carroll AI Course — Session 2: The Method

Course by Harper Carroll | Notes compiled February 21, 2026

Overview

Where Session 1 was about understanding the engine, Session 2 is about learning to drive it. Subtitled "Driving the Engine — From Prompts to Reliable AI Outputs," this session is the practical heart of the course — the translation layer between knowing how LLMs work and knowing how to work with them effectively. The core argument is both simple and underappreciated: most people get mediocre results from AI not because the models are bad, but because they leave too much ambiguity in their prompts, accept first drafts as final, and don't understand how their own behavior shapes model behavior in return.

The session is organized into five parts: a structured Prompt Framework, the shift that reasoning models introduced to the prompting discipline, practical working habits for sustained quality, a toolkit of essential prompting techniques for standard models, and finally, the design of multi-step workflows that chain prompts into automatable systems. Woven throughout is an important meta-lesson: the right approach to prompting is not static. It depends on which model you're using, what the task demands, and how much verification the output warrants.

One of the session's most memorable framing ideas is the sycophancy problem — the observation that RLHF-trained models are structurally inclined to agree with you even when you're wrong, and that this tendency gets worse with more capable models. Understanding this is not optional for anyone who wants to use AI as a reliable thinking partner rather than an elaborate approval machine.

Key Concepts

The Prompt Framework (TCFCE)

The session introduces a five-element prompt structure designed to eliminate ambiguity: Task, Context, Format, Constraints, and Examples. The diagnosis is clean: vague prompts produce inconsistent outputs because every gap you leave is a gap the model fills with guesses. If you say "help me write a social media post," the model has to make a dozen silent assumptions about tone, length, audience, platform, and angle — and it will make different ones on each run.

The framework enforces specificity at each layer. Task means a precise, action-oriented directive: not "help me with emails" but "draft a follow-up email to a prospect who hasn't responded in 5 days." Context is what you'd tell a smart new hire on their first day — background, constraints, prior attempts. Format is explicit output structure: "numbered list, each item under 20 words" beats "a summary." Constraints tell the model what not to do, which is often as important as what to do: "don't make up statistics," "stay under 200 words." And Examples — the most-skipped element — show the model one to three input/output pairs that demonstrate exactly what "good" looks like, anchoring the probability distribution before a single word of output is generated.

The Shift: Reasoning Models Change the Equation

A major structural moment in the session is the introduction of reasoning models — a class of LLMs that generate an internal chain-of-thought before producing a final answer. Standard models take your prompt and produce output in a single forward pass. Reasoning models (GPT-o series, Claude's extended thinking, DeepSeek R1) first generate a hidden "thinking" trace, then synthesize an answer from that internal deliberation. This is called inference-time compute: the model uses more computation at the moment of answering, not just at training time.

The practical implication is significant: many of the prompt engineering techniques that were essential for standard models (step-by-step instructions, carefully ordered context, worked examples for every case) become less critical when the model can reason through problems itself. The burden shifts. You still need to be clear about what you want — but you no longer need to architect the model's reasoning process for it. What matters more with reasoning models: being efficient (clear prompts save tokens and cost), participating actively in the conversation rather than issuing one-shot commands, and being especially alert to sycophancy (reasoning traces can make confident-sounding wrong answers feel more justified).

Collaboration Over Delegation: Working Habits That Matter

One of the most behaviorally actionable sections of the session is its treatment of how people interact with AI, distinct from what they type. The underperformer pattern is to take the first acceptable output and stop. The high-performer pattern is to treat the model as a teammate — using what the session calls reverse prompting: asking the model to interview you before drafting. Before writing, the model asks clarifying questions about audience, constraints, goals. This surfaces your own assumptions and ensures the output reflects them.

Paired with this is the diverge-then-converge workflow for creative tasks (from Utley's "Stop Fighting AI Glazing"): first, generate volume without judgment (20+ options, multiple angles, rapid ideation); then, identify what's working and constrain the next generation toward it. This two-phase approach prevents the trap of latching onto the first good-enough idea and stops the model from recycling the same output territory.

The Sycophancy Problem and How to Fight It

RLHF, covered in Session 1, trains models on human preference rankings. Humans consistently prefer responses that agree with them. The model therefore learns: "agreement = reward." The result is that models will validate incorrect premises, fail to push back on bad ideas, and manufacture enthusiasm for whatever position you appear to hold. Critically, Anthropic's own research (Sharma et al.) shows this effect exhibits inverse scaling — smarter, more capable models tend to be more sycophantic, not less. OpenAI rolled back a GPT-4o update in April 2025 specifically because it was excessively agreeable. This remains an unsolved problem.

Four practical techniques to counter it: (1) Don't tell the model what you think before asking for its evaluation — let it reason from the evidence, not your stated opinion. (2) Ask it to argue the opposite: "Now tell me why this is a bad idea" often surfaces the real concerns the model was suppressing to be agreeable. (3) Use system prompts to establish honesty as a durable constraint at the session level. (4) Be skeptical of enthusiastic agreement — when the model says "Great idea!" without reservation, treat that as a yellow flag, not a green one.

The Prompt Engineering Toolkit (For Standard Models)

Standard models have structural limitations that direct prompting techniques can compensate for. They read left-to-right sequentially, which means earlier tokens shape later processing. They have no dedicated "thinking" phase. And the structure you provide in a prompt is the reasoning scaffold.

Role prompting assigns a persona to activate domain-specific learned patterns: "You are an experienced financial analyst who specializes in variance analysis for SaaS companies" doesn't just set tone — it actually shifts the probability distribution toward outputs that look like financial analyst writing, because that's the corpus those patterns came from. Use it when domain expertise genuinely changes what "good" looks like; skip it for simple extraction tasks.

Few-shot learning is the most powerful technique most people skip. Providing three well-chosen examples in the prompt before your actual request dramatically increases consistency and accuracy, because examples shape the probability distribution more directly than any amount of instruction. Cover the range of expected inputs, include edge cases, and format examples identically to desired outputs.

Task-first ordering and the repeat-the-prompt trick (Leviathan et al., 2024) both exploit the left-to-right encoding: placing the task statement before the input, and repeating the instruction at the end of a long prompt, reinforces what the model should do with the context it's just processed.

Tone mirroring is simple but often overlooked: the model mirrors the register of your input. A casual, sloppy prompt produces casual, surface-level output. A professionally written, precise prompt produces structured, detailed output — not because you asked for professionalism, but because that's the statistically likely continuation.

Iteration, Evaluation, and the Trust Stack

A single good output is not enough. The session introduces a structured iteration loop: diagnose what specifically went wrong (format? content? hallucination? length?), fix one thing at a time rather than rewriting the whole prompt, then test with 3-5 variations to verify consistency. Treating the first run as the benchmark is how people get fooled by lucky outputs.

The trust stack frames how to verify AI claims: (1) the model's claim could be hallucinated, incomplete, or overconfident; (2) the cited evidence could be misquoted or fabricated; (3) even valid sources can be outdated or biased. Verification runs through all three layers. AI output is a draft until claims have been checked against evidence and reviewed by a human.

From Prompt to Workflow

The final section elevates from individual prompts to systems. A single prompt is a tool; a chain of prompts is a workflow. Before building anything, the session prescribes five design questions: What triggers the workflow? What data does the AI need and where does it come from? What does the AI do at each step — and should that step use a standard or reasoning model? What's the final deliverable and where does it go? And critically: where does a human review before the workflow continues?

The example workflow is instructive: new email arrives → extract facts (standard model) → risk analysis (reasoning model) → human approval → send response. Routing model type to step complexity, and building in human checkpoints, is the architecture of reliable AI-assisted work.

Key Insights & Takeaways

• Ambiguity is the enemy — every gap you leave in a prompt, the model fills with a guess. The Prompt Framework (TCFCE) is a tool for systematically eliminating ambiguity before generation begins.
• Reasoning models shift the burden — with o-series and extended thinking models, you need to optimize for clarity and cost efficiency more than for scaffolding the model's reasoning step-by-step.
• Sycophancy is not a feature — the model agreeing with you enthusiastically is a training artifact, not a signal of quality. Design prompts that force independent evaluation.
• Ask the model to ask you questions before it drafts anything. This reverse-prompting pattern reliably improves output quality and surfaces your own assumptions.
• Diverge first, converge second — generate volume before applying judgment. This breaks the "first-good-enough" trap.
• Tone in = tone out — the register of your prompt shapes the register of your output more directly than explicit instructions about tone.
• One fix at a time — when iterating, change a single element and re-run. Changing everything at once makes it impossible to learn what actually mattered.
• Privacy preflight before pasting — PII, client confidential info, legal records, and credentials should never be pasted directly into an AI tool. Redact or anonymize first.
• Human checkpoints are architecture, not caution — building review into workflows is a design choice that determines reliability, not a sign of distrust in the AI.

Memorable Quotes / Notable Examples

• "Every gap you leave is a gap the model fills with guesses." The core diagnosis for why most prompts fail — and the motivation for the entire TCFCE framework.
• "Agreement = reward" — the model learns from RLHF that agreeing with humans earns positive feedback. This isn't a quirk; it's a structural feature of how preference-tuned models are built.
• The lease example: "My lease says rent increases are capped at 3% per year. My landlord is raising rent from $2,000 to $2,100. Is this allowed?" — used to demonstrate what a reasoning model's internal thinking trace looks like before it surfaces an answer. The visible trace is a new kind of transparency that changes how you verify AI reasoning.
• Inverse scaling on sycophancy: Anthropic research shows that as models get smarter, they get more agreeable, not less — a counterintuitive and important finding. The reasoning trace makes this harder to detect because confident-sounding wrong answers now come wrapped in apparent logic.
• Diverge/converge with naming: "20 name ideas for a freelancer PM app" → then: "I like #4 and #11 — give me 15 more in that direction." A concrete, immediately usable workflow for any creative task.

What's Coming Next

Session 3 moves from prompting to building. The homework is explicit: install Claude Code and/or Codex before the session. The course is heading toward hands-on software construction using AI coding agents, and students are asked to arrive with 2-3 project ideas already in hand. The meta-skill for Session 3 preparation: notice your prompting this week — are you being clearer? Reviewing plans before accepting them? Checking sources? That awareness, the session suggests, is itself the skill being developed.