Ambition skill

Skill that rewrites a task into a bolder brief: the goal beyond the goal, a top specialist approach, methods from other fields.

  • 112 ★ on the repository
  • Last commit
Skill

Minimal access

Why this level

  • The skill only reads task materials and writes a brief, and performs no actions in the outside world.
All reasons and checks

wanderingspirit03/ambition-skill

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/ambition

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Minimal accessThe tool runs nothing and makes no network calls.

  • The skill only reads task materials and writes a brief, and performs no actions in the outside world.

This is third-party code. Review the repository files before installing.

What it does

The skill follows the method from Felix Rieseberg's essay "How to be more ambitious: a tutorial for humans with models": altitude, depth and range. The agent first reads the task materials and finds out which data and access exist. It then writes three versions: altitude (what outcome is wanted after the task), depth (what the field's best practitioner would do, from which raw material, and what judges the result) and range (which methods from adjacent fields to bring in). The result is a short brief under 450 words. The agent ends by asking which version to pick and does not start work until you answer. Steps that send messages, spend money or change live data are marked "needs your OK".

Who it is for. People who give an agent a narrow task and suspect that the real goal is broader and the approach can be stronger.

Good fit when

  • A quarterly deck should become a way to catch problems earlier.
  • You want to compare how a top specialist would solve it and use an independent check of the result.
  • The task is worth solving with methods from adjacent fields, say from an independent auditor's standpoint.
  • A short brief with time and money cost for each version is wanted before big work.

Not a fit when

  • The task is ordinary and nobody asked to expand it; the skill is invoked only on request.
  • You just want the same thing faster; the skill does not help with speed.
  • The work is creative, where "altitude" fits less well, and the author warns about it.

Example request

/ambition Prepare the quarterly sales report.

Limitations

The skill does not do the work: it writes a brief and waits for your choice. It rests on one essay, with a detailed summary in `references/essay-notes.md`. The altitude version needs access and data the agent may lack, and then obtaining them becomes the first step. The author warns that altitude fits creative work less well. Each version names its cost in time and money, but the agent estimates it roughly and measures nothing before you agree. The repository states no license. Invoke it with `/ambition` or the words "make this more ambitious".

How to disable. Delete the `~/.claude/skills/ambition` folder.

FAQ

How do I install it?

With `git clone https://github.com/wanderingspirit03/ambition-skill ~/.claude/skills/ambition`. After that the skill runs through `/ambition`.

When does the agent start the work?

Only after you pick a version, a mix or edits. The skill stops at the brief because the versions differ in scope, cost and the people affected.

What is an outside judge?

A check of the result by something other than the agent's own opinion: a test suite, a held-out set, a replay of historical data, a real user's action or a blind expert score.

Why is speed skipped?

The author holds that models already do the same work faster, so the skill goes up, deep and wide and skips speed.

Do I need to read the essay?

No. The agent reads a short summary with examples from `references/essay-notes.md` on the first call in a session or on a hard task.

Discussion

No questions or reviews yet.

Skills

A parallel divergent ideation skill for agents: fans out under cognitive frames, prunes traps and deepens the best branches

SkillExtended access4.5KRepository stars

A completion-discipline skill for large agent tasks: write the acceptance ledger with runnable checks first, then do the work, then reverify against evidence

SkillExtended access4.4KRepository stars

A skill that scores a prompt on five criteria, picks one of 31 frameworks and rewrites the request after clarifying questions

SkillMinimal access333Repository stars

A skill that keeps an agent off its own hashes, locks and receipts: ship the output first, then verify

SkillExtended access185Repository stars

Agents Best Practices

agents-best-practices

A provider-neutral skill for designing agent systems: loop architecture, tools, permissions, memory and observability

SkillMinimal access2.4KRepository stars

A workshop skill: the agent vets a finished skill, finds peers, scores it and edits step by step, testing every change.

SkillExtended access967Repository stars

README in short

The skill turns the essay method into a working routine for an agent: three steps of altitude, depth and range, with a brief check for concreteness, cost and approval limits. The repository has two files and a reference.

README badge

Original SKILL.md

---
name: ambition
description: Rewrites a task the user gives into a more ambitious version using Felix Rieseberg's altitude, depth and range method, shows it as a short brief, and waits for the user to choose before doing any of the work. Use it only when the user asks for it, e.g. "/ambition", "be more ambitious", "make this more ambitious", "what's the ambitious version of this", or when they name altitude, depth or range. Don't use it on ordinary tasks they haven't asked to expand.
---

# Ambition

Felix Rieseberg's essay "How to be more ambitious: a tutorial for humans with models" (13 October 2026) is written for the person prompting the model. Its argument is that the person usually limits the result, because they ask for the task instead of the outcome, hand over digested data instead of raw data, and stay inside one field. When the user calls this skill, you do their half of that work. You rewrite their task the way they would if they applied the essay, show them the rewrite, and wait for them to choose.

The essay names four kinds of ambition:
- **Speed:** the same work in less time. Models already do this by default, so skip it.
- **Altitude:** aim at the outcome beyond the task.
- **Depth:** do the task the way the field's best practitioner would.
- **Range:** bring in methods from fields the task doesn't obviously need.

A short summary of the essay, with its worked examples, is in `references/essay-notes.md`. Read it the first time you use this skill in a session, or when a task is hard to lift.

## Workflow

### 1. Look before you lift
Read what the task touches first, e.g. the code, the data, the earlier messages or the files the user mentions. Find out what data, tools and access exist. An ambitious version built on a wrong idea of what's available is useless, and the altitude version in particular depends on what you can reach. Reading is fine at this stage, but don't start the work itself.

### 2. Write the altitude version
Ask what the user wants to happen after the task is done, and what the goal beyond the goal is. Climb in rungs, the way the essay climbs from "make the quarterly deck" to "design a better way for leadership to catch problems early":
- **Rung 1:** the same task, but with all the data you can get, aimed at what changed, why, and what to do about it.
- **Rung 2:** the decisions the task feeds. Work out which ones are most urgent and draft options with the case for and against.
- **Rung 3:** the standing job the task exists to serve. Design a better way to do that job, show from the user's own history that it would have worked sooner, and propose running it next to the current way for a while.

Altitude fits best when the work leads to meetings or decisions, or comes back again and again. It fits less well for creative work, so say so when that's the case.

Name the wiring. To own an outcome instead of a task, you need access that the user would otherwise supply by hand each time, e.g. to keep apps free of crashes, Felix first gave Claude crash reports, a map from app version to commit, and machines to reproduce bugs on. List the missing access or data as the first steps, because without it the altitude version turns back into a list of tasks.

### 3. Write the depth version
Answer the essay's four questions:
1. What would a top professional in this field do here that the user isn't asking for?
2. What is the rawest material they would start from, instead of what has already been summarised?
3. Which specific methods and tools would they use? Name the instruments, not the vocabulary, e.g. a database and a statistical model instead of a markdown table. Models asked to act like experts tend to switch words without switching methods, so check that the method itself changed.
4. What, other than you or the user, would show the result is right? This is the outside judge. The best judge is one you can run yourself for fast feedback, e.g. a test suite, a held-out evaluation set, a replay of historical data, a real user's action, or an expert scoring blind. Don't use your own opinion of your work as the judge.

Then add these:

Report a problem