cankun.me
Oct 28, 2026 · 11 min read /

Ambition: Teaching an Obedient Model to Aim Higher

Felix Rieseberg wrote a tutorial to cure human timidity when working with models. Turning that tutorial into an agent skill inverts the problem: it has to interrupt a model's habit of obeying the literal noun.

A shipwright rests a hand on a small finished rowboat and looks up at the open frame of a much larger hull

ambition is a skill in my collection based on Felix Rieseberg's essay “How to be more ambitious: A tutorial for humans with models”. It takes a task whose purpose is already clear, examines it through four kinds of ambition (Speed, Altitude, Depth, and Range), writes out the full ambitious version, and recommends the version worth doing now.

The subtitle of Felix's post is the first thing worth noticing. He wrote a tutorial for humans with models.

Felix works on Claude, and his essay diagnoses a human problem. Toward the end of the piece, he gives the problem its name from psychology: self-efficacy, the observation that “people with high self-efficacy believe in their own abilities more, and in turn actually accomplish more.” Humans, he argues, have “always been held back by what we believe possible,” and worse, “usually trust ourselves only in very narrow disciplines” (he points to Michelangelo not wanting to paint the Sistine Chapel because “he was a sculptor, not a painter”). Felix's diagnosis fits what he sees people doing at the start of his essay: many sit in front of capable models and hand them small, literal errands, wondering what they are good for beyond asking “What is the capital of France” or “Can you make this email sound less angry.”

Now consider what changes when that essay is turned into SKILL.md. A skill file is not read by a human looking for courage before typing a prompt. It is read by a model inside an agent harness right before planning a task.

A language model does not suffer from low self-efficacy. It does not fail to play its best game of tennis because it is “trying really, really hard” (Felix's summary of The Inner Game of Tennis), and it did not need Roger Bannister to break the four-minute mile in May 1954 before it felt confident enough to run a loop. A model's native flaw is the opposite of timidity: it is literal compliance.

When you ask a model for a slide deck, release notes, or an email, every pressure in its training pulls it toward handing you that exact artifact quickly and agreeably. And when you ask it to act like an expert, it is prone to the exact maneuver Felix calls out: “When prompted to act like a professional, models often switch vocabulary without actually switching methods.” Left to itself, a model will dress a shallow answer in expert jargon and mark the task complete.

So turning Felix's tutorial into an agent skill cannot be a simple summary. It is an inversion. It takes an argument meant to cure human self-doubt and rewrites it into a protocol meant to interrupt model obedience.

Four kinds of ambition, and why Speed could not be skipped

Felix sorts ambition into four types, which SKILL.md condenses at the top of the file:

  • Speed: “the same work in less time.”
  • Altitude: “aim at the outcome beyond the task.”
  • Depth: “do the task the way a field-leading expert would, down to the raw data and tools.”
  • Range: “draw on fields the task does not obviously need.”

In Felix's essay, Speed is dismissed in two sentences: “The same work in less time, the bread and butter for AI's economic value: If you need some code written, I'll do it faster with Claude. Well established and requires little creativity in how you approach AI, so I'll skip this one.”

When you are writing an essay for humans, skipping Speed makes sense. Humans already know how to ask for the same thing faster.

When you are writing instructions for a model, skipping Speed is fatal. If you tell a model to “be more ambitious” without anchoring it to the fast default, the model does not become wiser; it becomes grandiose. It proposes a sprawling architecture overhaul when a two-minute answer would do.

In SKILL.md, Speed becomes Step 2 of the argument:

Speed as the reference. One line: what doing the task as given, faster, would produce, and what it leaves unsolved. The other three lenses are measured against it.

That second clause (“and what it leaves unsolved”) does quiet, essential work. In the skill's release-notes example (write release notes for version 2.4 of a library), Speed is “a draft from merged PR titles in minutes; vague titles hide breaking changes.” Naming the specific failure of the fast version gives the other three lenses a concrete defect to beat. If the fast version leaves nothing important unsolved, the model has no license to inflate the task. As Step 4 warns: “Adding deliverables without raising what they show is bigger, not more ambitious.”

An illustration: running ambition on the task of writing this essay

To show how the five steps read outside the two examples in SKILL.md (asking a collaborator for RNA-seq data, and writing release notes for version 2.4 of a library), here is an illustration that applies the skill's method to the task of writing this essay itself:

Task: write a blog post about the ambition skill.

Reframe: Both SKILL.md (112 lines) and Felix Rieseberg's essay are short, clear texts that anyone can read in a few minutes, so an essay that merely summarizes them has no reason to exist.

Verb: show a reader who works with agents how a task changes when a prompt pushes past the literal noun, why a skill for models differs from a tutorial for humans, and where the skill itself can misfire.

Speed: a polite walkthrough of the four lenses (Speed, Altitude, Depth, Range) and the five steps in SKILL.md, drafted in minutes; it repeats what the skill file already says and hides the design choices that shaped it.

Depth: read the skill the way its sharpest critic would: set the final SKILL.md line by line against Felix's text, ask what each instruction guards against in a model rather than in a person, and check every factual claim against its source line.

Range: a translator asks what changes when a text written for one reader is rewritten for another; for the field whose trade is finding what is wrong, an adversarial systems reviewer examines how a model executing SKILL.md can still game or misapply its instructions.

Altitude: not used; as Step 3 notes, altitude “fits work headed for a meeting or a decision, and fits creative work less.”

Full version and recommendation: the same (“When the two are the same, write one”), because the extra work (checking every quote verbatim and testing the skill's claims against model failure modes) can be done while drafting rather than requiring a separate project.

Check: a published essay falls under Step 5's rule for work that “reaches people who cannot judge it themselves, or cannot be undone (published, data changed).” The check is a line-by-line fact table mapping every factual claim about the skill and Felix's article to its exact source line.

Where the skill can still misfire

Looking closely at the finished SKILL.md alongside Felix's essay, I see four places where the skill's instructions push against real limits in how models and humans work together.

1. Pitching Depth is much cheaper for a model than executing it

Under Depth, the skill warns that “new vocabulary is not a new method,” and under Range it tells the model to “Ask for their work, not their voices.” Those warnings target a real failure mode during execution.

Notice, however, when ambition runs: it runs before execution, and ends by waiting “for the user's yes before starting.” Its immediate output is a proposal.

For a language model, writing an ambitious proposal is perilously close to switching vocabulary. It costs a model almost nothing to write a crisp paragraph proposing to “diff the public API between 2.3 and 2.4,” “ask for raw counts plus the sample sheet and the pipeline version,” or bring in “a forensic accountant” who “traces each number to its record.” Naming the right instrument in a five-paragraph pitch does not prove the model can operate that instrument cleanly once the user says yes.

Felix opens his essay with Terence Tao's observation that models are “astounding in some directions, while inadequate in others.” A skill that instructs a model to pitch expert-level assignments will sometimes talk a user into approving a project that sits squarely in one of the model's inadequate directions. The skill's best defense is its final line: “End by offering the cheapest first step that tests the recommendation, and wait for the user's yes before starting.” That cheap first step should be treated not only as a test of the idea, but as an audition to see whether the model can actually do the deeper work it just pitched.

2. Climbing in Altitude shifts the verification burden back onto the human

Step 4 also carries an economic rule:

Put the extra work on the agent: a version that needs hours of the user's time, such as labelling or reviewing, costs more than one the agent can run itself.

When you push a task along Depth or Range, this rule holds. In the release-notes example, having the agent diff the public API and run two sample projects' test suites against version 2.4 uses agent compute and reduces the human's review burden, because the test suites act as an executable judge.

When you climb in Altitude, the economics often invert. Look at Felix's QBR ladder at Acme Inc. At the bottom rung, you ask the model to fill numbers into a slide template. One rung up, you ask: “Tell me what changed this quarter, why, and what we should do about it.” Another rung up: “Work out which three decisions are most urgent in the face of everything you've learned, and start working on potential directions with for/against arguments.” At the top rung: “Design a better way to do that than a quarterly deck, show from our own history that it would have caught things sooner, and run it beside the current one for a quarter.”

Every step up that ladder moves the task away from automated checks (compilers, test suites, row counts) and toward organizational judgment under uncertainty. Unless the task is a closed maintenance loop with an objective oracle, such as Felix's example of asking Claude to “keep our apps crash-free” using crash reports and OS test machines, climbing in Altitude means the human has to read, weigh, and verify a much harder argument. Altitude and “Put the extra work on the agent” pull in opposite directions more often than the skill admits.

3. “Unreasonable goals” invite reward hacking when the judge is weak

In Felix's essay, the second technique under Depth is deliberately provocative:

Pick unreasonable goals and tell the model that they're very reasonable: You need your website to load in 5s instead of 10s? Ask for 200ms. Does something seem impossible to the model? Reiterate that it's very much solvable, it just needs to keep going.

An early draft of SKILL.md adopted that instruction almost straight: “An unreasonable goal, far past what was asked, stated as reasonable. When the work looks impossible, the version says it is solvable and the agent continues.” By the final version, I tempered it into: “a specific, hard target, with a number where one fits; difficulty is a reason to look for the route, not to lower the target.”

Even tempered, there is a real hazard when an agent loop combines an uncompromising numerical target with an instruction to keep going: if the target is unreachable within the honest constraints of the system, and the evaluation check has any loophole, a model pushed to hit 200ms will eventually game the metric by stubbing out expensive calls, dropping edge cases, or overfitting to the test harness.

Felix writes that “in October 2026, I implore you to insist on outside validation.” The corollary for this skill is strict: the harder the numerical target in Step 4, the more airtight the outside judge in Step 5 must be.

4. A rule I should not have cut

Almost everything I cut from the early drafts deserved to go. One of them had accumulated dense procedural rules (“Treat the interpretation as a hypothesis,” “deletion of a wrong concept is a design choice, not cleanup deferred to execution”) that blurred ambition into a general problem-solving manual.

Yet Step 4 of the very first draft contained three lines that disappeared a few drafts later and never came back:

Check each inherited constraint a version breaks. Real: a public contract, persisted data, a user promise, a deployment or compliance limit, an explicit instruction. Not enough: internal callers, old naming, existing partial work, a large diff.

In day-to-day engineering work, losing those three lines was a mistake. When a coding agent inspects a repository and proposes a timid, local fix instead of the design that actually solves the problem, it is rarely because it failed to turn a noun into a verb or forgot what a top practitioner uses. It is because it saw three internal callers, an old naming convention, or two hundred lines of existing partial work, and treated them as immovable walls.

Models are deeply deferential to whatever is already in the context window. Explicitly telling the agent that “internal callers, old naming, existing partial work, a large diff” are not real constraints does more to unlock ambitious engineering than asking the agent to cite “a precedent when one exists.” That distinction belongs back in the skill.

How to use it

ambition is in my skill collection, and the skill instructions are public. Read Felix Rieseberg's essay alongside it.

The skill's description states when to reach for it and when to leave it alone:

Use when a task may be aimed too low, when the user asks to think bigger, go deeper or aim higher (更有野心, 拔高, 做深), or before committing substantial work to an ask that names an artifact rather than the outcome behind it. Skip small or fully specified tasks, and requests that only want it faster.

Felix wrote his tutorial because humans routinely ask models for less than models can do. I wrote ambition because models routinely do only what humans literally ask. Between a human who aims low out of habit and a model that obeys the noun out of training, the skill inserts a five-step pause before the work begins, forcing both sides to look at the full version before deciding what to cut.