# How to Be More Ambitious: Working with Frontier AI Models

> Learn how to scale ambition with AI by delegating outcomes, mastering Altitude, Depth, and Range, and building environments for maximum model performance.

Source: https://camnangai.com/en/knowledge/how-to-be-more-ambitious-with-ai-models  
Published: 2026-10-20

Scaling human capability through frontier models requires moving past trivial task automation
  toward managing high-abstraction autonomous systems.

Most engineers restrict large language models to basic Q&A, minor text rephrasing, or localized code
edits. To systematically scale your **ambition with AI**, you must re-architect how you interface
with these systems across every domain of engineering, analysis, and execution.

Model capabilities do not scale uniformly across all dimensions. As [**Terence Tao**](https://terrytao.wordpress.com) observes, frontier models are astounding in some directions while inadequate in others. You likely struggle to get these tools to function reliably because you attempt to use them for basic lookup tasks or minor code fixes, failing to realize that frontier models can write complete software suites, analyze raw multi-gigabyte datasets, and execute end-to-end operational workflows when given direct environment access.


  True leverage lies in systematically unlocking Altitude, Depth, and Range to achieve technical
  outcomes previously considered impossible for individual engineers or small teams.


To overcome these artificial constraints, you must systematically evaluate and elevate your work along the four axes of ambition defined by [**Felix Rieseberg**](https://felixrieseberg.com): Speed, Altitude, Depth, and Range. Plain Speed—doing the exact same work faster—is baseline economic table stakes that requires minimal structural creativity.

![The four dimensions of ambition with AI models: Speed, Altitude, Depth, and Range](https://camnangai.com/articles/tham-vong-hon-voi-mo-hinh-ai/01-infographic-en.webp)

## Why We Are Far Too Timid with AI Models

You are likely deploying frontier AI models for low-ambition micro-tasks: requesting capitals of countries, adjusting the tone of internal emails, or generating brief boilerplate functions. In stark contrast, high-ambition implementations demonstrate that frontier models can assist amateur astronomers in discovering new planets, generate complete and artistically coherent music videos, and drive foundational paradigm shifts in pure mathematics, such as the transition to Math 2.0. The disconnect between model capability and actual human utilization stems from a failure to recognize the true performance ceiling of frontier systems.

![The Jagged Frontier of model capability and the drop in consultant accuracy outside the capability boundary](https://camnangai.com/articles/tham-vong-hon-voi-mo-hinh-ai/02-en.webp)

Empirical data reveals a massive performance lift when you leverage frontier models effectively. A randomized controlled trial led by [**Ethan Mollick**](https://www.oneusefulthing.org) and Boston Consulting Group (BCG) across 758 consultants—representing 7% of BCG's workforce—tested performance across 18 realistic business tasks, including market segmentation, creative ideation, and persuasive writing. Consultants equipped with GPT-4 completed 12.2% more tasks, finished tasks 25.1% faster, and produced results rated 40% higher in quality compared to the control group without AI. Furthermore, model access acted as a powerful skill leveler: consultants in the lowest baseline performance tier experienced a 43% performance jump when provided with GPT-4 access.

Despite these dramatic gains, navigating frontier models requires understanding the concept of the **Jagged Frontier**. The boundary of model capability is invisible, non-linear, and counterintuitive. A model can effortlessly write an intricate Shakespearean sonnet but fail to write a poem containing exactly 50 words due to tokenization mechanics; similarly, it can excel at ideating ten novel product concepts for underserved markets while making elementary arithmetic errors on raw numerical streams. Tasks that appear logically identical in difficulty to a human engineer frequently lie on opposite sides of the capability wall.

When you fail to map the Jagged Frontier, you risk severe performance degradation by falling asleep at the wheel. On tasks specifically designed to lie outside the AI's capability wall—where the model produces wrong but authoritative and convincing answers—consultants relying on AI dropped in accuracy from 84% (without AI) to 60–70% (with AI). Research on job recruiters highlighted the root cause of this failure mode: recruiters using high-quality AI became careless, ultimately missing out on top applicants and making worse hiring decisions than recruiters using low-quality AI or no AI at all. High output quality and authoritative syntax induce human carelessness, causing you to accept incorrect outputs blindly unless you enforce strict external validation.

## Altitude: Shifting from Micro-Tasks to Macro-Outcomes

**Altitude** represents moving up the abstraction ladder to focus entirely on the ultimate operational outcome rather than guiding step-by-step task execution. Increasing altitude requires asking a fundamental question before submitting any prompt: what is the goal beyond the goal? Low-altitude execution forces you to act as a micro-manager, manually feeding instructions, inspecting minor code edits, and stringing together isolated sub-tasks. High-altitude execution transfers the operational burden of orchestration to the model, elevating you to an executive evaluator.

![The three tiers of abstraction in Altitude: from micro-task prompt to automated operational monitor](https://camnangai.com/articles/tham-vong-hon-voi-mo-hinh-ai/03-en.webp)

Consider a standard corporate operational requirement: assembling a Quarterly Business Review (QBR) deck. A low-altitude approach asks the model to update numerical tables in a pre-existing slide template or rewrite bullet points for clarity. Elevating altitude transforms this task through three progressive tiers of abstraction. In Tier 1, you supply raw telemetry, JSON log streams, customer support records, and database query results directly to the model with the prompt: "Identify what structural changes occurred this quarter, explain why they occurred, and specify what actions leadership should take." In Tier 2, you force a decision framework: "Determine which three decisions are most urgent based on overall business telemetry, draft comprehensive arguments for and against each direction, and outline the resource allocation required."

In Tier 3, you re-engineer the underlying process entirely. Instead of generating a deck, you instruct the model: "The review exists so leadership catches operational anomalies early and reallocates capital and headcount automatically. Design an automated monitoring architecture that detects these anomalies continuously, prove from our own historical log data that it would have caught operational issues sooner, and run it alongside the current quarterly review process for one trial period." This shifts the model from a presentation formatting tool to an active operational monitor validated against historical ground truth.

To sustain high-altitude autonomy, you must engineer infrastructure that removes human bottlenecks from intermediate execution loops. Models cannot maintain crash-free software applications or optimize infrastructure if they are restricted to web-based chat boxes. You must grant systems direct execution privileges across relevant operating environments—enabling them to fetch real-time crash reports via APIs, map stack trace line numbers directly to git commits, instantiate isolated build sandboxes, and independently verify fixes before submitting pull requests.

```text
[MICRO-TASK PROMPT]
"Fix the null pointer exception on line 42 of auth_controller.py and format the output as markdown."

[MACRO-OUTCOME PROMPT]
"Connect to the crash logging API, pull all authentication failures from the current release, map them to git commits, reproduce the issues in a sandboxed environment, and submit pull requests that keep application crash rates below 0.01%."
```

## Depth: Demanding the Instruments and Rigor of Top Experts

Operating with **Depth** requires bypassing surface-level summaries and forcing the model to operate at the foundational layer of a discipline. Depth demands using the exact raw datasets, analytical instruments, algorithms, and statistical frameworks employed by world-class domain specialists. When prompted casually, language models default to superficial output formats—such as qualitative summaries, basic markdown tables, and generic overviews—rather than rigorous analytical execution.

![The four pillars of Depth: expert methods, raw data streams, specialized tools, and external verification engines](https://camnangai.com/articles/tham-vong-hon-voi-mo-hinh-ai/04-en.webp)

Achieving extreme Depth requires you to enforce specific operational methods across your prompts. First, insist on industry-standard instruments by rejecting qualitative text summaries and demanding raw executable SQL queries, statistical regression models, and automated test scripts. Second, assert unreasonable performance targets; if you need a web application's page load latency reduced from 10 seconds down to 200 milliseconds, instruct the model that a 200ms target is fully achievable and mandate that it iterate until the target is met. Third, enforce adversarial assumption testing by supplying raw event logs and commanding the model to disprove core organizational beliefs—such as proving whether user churn is driven by onboarding friction or post-onboarding performance degradation.

Fourth, direct the model to produce new knowledge by building predictive simulations based on historical log streams to identify undiscovered predictive signals on unseen test data. Fifth, strictly enforce outside verification by forbidding models from evaluating their own correctness. You must require validation through external deterministic mechanisms, such as compiler execution, unit test suites, or mathematical verification engines. To apply these depth principles systematically across arbitrary engineering tasks, apply Felix Rieseberg's 4-step prompt transformation framework before initiating execution:

```text
I want a deeper version of this task, not a bigger one. Before rewriting it:
1. State what a top professional in this field would do here that I am not asking for.
2. Name the rawest material they would start from instead of what has been digested.
3. Name the specific methods, algorithms, and tools they would use.
4. Specify what external system (other than you or me) will prove the result is correct.
Then rewrite my prompt to ask for exactly that.
```

## Range: Crossing Disciplines and Assembling Multi-Agent Teams

**Range** is the capacity to intersect multiple disparate specialized disciplines, mental models, and toolsets to address complex engineering problems. By leveraging frontier models, cross-disciplinary synthesis becomes economically feasible at scale. Combining methodologies from software engineering, forensic accounting, competitive intelligence, and system dynamics allows you to uncover operational vulnerabilities that a single-domain approach inevitably misses.

![Multi-agent topologies for Range: Routing, Parallelization, Orchestrator-Workers, and Evaluator-Optimizer](https://camnangai.com/articles/tham-vong-hon-voi-mo-hinh-ai/05-en.webp)

Unlocking multi-disciplinary Range requires converting passive task nouns into operational verbs, a technique pioneered by Tom Kelley and Jonathan Littman (_The Art of Innovation_). An internal presentation deck is not "a slide deck"; it is "getting busy executives to understand cause and effect under uncertainty and make capital allocation decisions in 30 minutes." By framing the problem around operational verbs, you identify which specialized disciplines—such as narrative architecture, decision theory, and quantitative risk modeling—must be incorporated into the execution loop.

Rather than relying on generic model personalities, you must construct multi-agent teams configured with functional role architectures. You can red-team an enterprise strategy by assembling a synthetic crew composed of a quantitative analyst, an investigative journalist, a short seller, and a forensic accountant. Each agent must be instructed to execute the precise concrete techniques of their field—such as inspecting balance sheet anomalies or parsing AST commit logs—rather than adopting superficial stylistic roleplay.

```yaml
orchestrator_agent:
  task: "Audit enterprise codebase for security vulnerabilities"
  workflow: orchestrator-workers
  workers:
    - worker_id: "static_analyzer"
      role: "Parse ASTs and run static vulnerability scanners"
    - worker_id: "forensic_accountant"
      role: "Audit financial logging logic for state manipulation"
    - worker_id: "red_team_adversary"
      role: "Draft exploit payloads against exposed API endpoints"
  synthesis:
    evaluator: "security_lead_agent"
    criteria: "Pass automated unit tests and eliminate false positives"
```

To coordinate these agents effectively, deploy structural architectures defined by Anthropic:

- **Parallelization**: Sectioning splits tasks into independent calls while voting mechanisms aggregate findings across multiple instances using defined threshold logic to flag vulnerabilities.
- **Orchestrator-Workers**: A central LLM dynamic orchestrator receives state parameters, parses unstructured inputs, delegates subtasks to worker LLMs, and synthesizes structured state outputs.
- **Evaluator-Optimizer**: A generator model produces artifacts while a separate evaluator model parses structured critique against target criteria, passing explicit feedback arrays back to the generator to trigger iterative retry loops.

Within these multi-agent environments, choose your operational posture based on Ethan Mollick's collaboration models. As a **Centaur**, you maintain a strict, transparent division of labor, explicitly routing sub-tasks based on relative strengths—for example, you design the statistical methodology while the model executes code generation and data visualization. As a **Cyborg**, you tightly interweave your work with the model at every step, co-creating solutions line-by-line in a continuous feedback loop across the Jagged Frontier.

## Environment Setup: The Technical Foundation for Real Model Autonomy

To grant AI models true operational autonomy, you must move beyond browser-based chat interfaces and construct a robust integration layer. The [**Model Context Protocol (MCP)**](https://modelcontextprotocol.io) serves as the open-source standardized interface—acting as a universal USB-C port for AI applications—connecting models directly to external technical systems. MCP allows models to interface natively with local filesystems, relational databases, search engines, and integrated development environments without writing fragmented, custom integration glue code.

![Model Context Protocol (MCP) and Agent-Computer Interface (ACI) architecture for model autonomy](https://camnangai.com/articles/tham-vong-hon-voi-mo-hinh-ai/06-en.webp)

```json
{
  "name": "read_source_file",
  "description": "Reads full file content from workspace. Requires absolute file path to prevent directory drift.",
  "parameters": {
    "type": "object",
    "properties": {
      "absolute_file_path": {
        "type": "string",
        "description": "Fully qualified absolute path (e.g., '/usr/var/app/src/main.py'). Relative paths are strictly rejected."
      }
    },
    "required": ["absolute_file_path"]
  }
}
```

Building effective Agent-Computer Interfaces (ACI) requires applying rigorous prompt engineering directly to tool definitions based on Anthropic's production findings. First, provide thinking space by allocating sufficient reasoning context tokens for the model to plan its execution path before generating structured tool output blocks. Second, eliminate formatting overhead that forces models into high-error generation modes. Tool formats requiring models to calculate git diff headers force the LLM to track exact line counts before writing modified code, while embedding code inside JSON schemas requires heavy string-escaping of quotes and newlines. Using standard markdown or clean data structures eliminates these failure modes entirely.

Third, apply Poka-Yoke (error-proofing) to constrain tool parameters structurally. In Anthropic's production evaluations on SWE-bench, models frequently failed when attempting to navigate file directories using relative filepaths after executing directory-changing commands. Forcing tool schemas to require fully qualified absolute filepaths completely eliminated directory navigation errors.

When architecting autonomous systems, you must distinguish between Workflows and Agents. Workflows execute predefined, deterministic code paths using orchestrated model calls, such as prompt chaining or conditional routing. Agents operate dynamically in open-ended environments, directing their own execution loops, selecting tools on the fly, and recovering from runtime exceptions based on environmental ground truth. Always build your initial systems using direct API calls and simple workflows, introducing dynamic agentic loops only when deterministic code paths fail to handle task complexity.

## The Psychology of Ambition: Self-Efficacy and the Power of Unreasonable Goals

Your execution capacity is fundamentally constrained by perceived possibility. In psychological literature, Albert Bandura defines **self-efficacy** as an individual's task-specific confidence in their ability to execute actions required to achieve designated performance levels. Locke and Latham's 35-year empirical research program on Goal-Setting Theory proves that setting specific, hard goals consistently produces higher performance than general instructions to "do your best." Meta-analytic effect sizes for goal difficulty range from d = 0.52 to d = 0.82, while specific hard goals outperform "do-your-best" directives with meta-analytic effect sizes ranging from d = 0.42 to d = 0.80.

![The four mechanisms of goal setting and shattering perceived psychological ceilings on self-efficacy](https://camnangai.com/articles/tham-vong-hon-voi-mo-hinh-ai/07-en.webp)

Locke and Latham establish that goal setting operates through four explicit mechanisms backed by extensive empirical research:

- **Directive function**: Steering attention and effort toward goal-relevant activities.
- **Energizing function**: Higher goals elicit greater physical and cognitive effort.
- **Persistence**: Prolonging effort over time, where tight deadlines force a significantly faster work pace.
- **Strategy discovery**: Forcing individuals to search for, adapt, or invent novel problem-solving methods.

Perceptual barriers severely restrict execution until a single breakthrough shatters perceived impossibility. In 1939, mathematician George Dantzig arrived late to a Berkeley statistics lecture, mistook two famous unsolved statistics problems on the blackboard for homework, and solved them both within days. Similarly, after Roger Bannister broke the sub-4-minute mile in May 1954, a second runner surpassed his record just 46 days later. You can eliminate evaluative anxiety and unlock strategy discovery by giving yourself explicit permission to fail—much like Linus Torvalds framing Linux as "just a hobby, won't be big and professional like gnu."

[**Patrick Collison**](https://patrickcollison.com)'s historical analysis of high-velocity engineering demonstrates that human teams achieve extraordinary speed when operating with high self-efficacy. In software systems, Brendan Eich prototyped JavaScript in 10 days, Linus Torvalds built a self-hosting version of Git in 4 days, and Ken Thompson wrote the first version of Unix in 3 weeks. In aerospace and hardware engineering, Kelly Johnson delivered the P-80 Shooting Star jet fighter in 143 days, and Tony Fadell shipped the original iPod in 290 days. In physical infrastructure, the Pentagon was completed in 491 days, and the 1,700-mile Alaska Highway was built across remote tundra in 234 days.

Modern administrative and technical environments present a stark contrast to these historical metrics due to bureaucratic decay. The San Francisco Van Ness bus lane project required approximately 7,600 days to complete at a staggering cost of $110,000 per meter ($346 million total). By comparison, the Alaska Highway was constructed in 1942 at a cost of $793 per meter in 2019 dollars. By pairing frontier AI systems with automated verification, you can bypass modern bureaucratic decay, reclaiming historical levels of rapid execution by setting audacious targets backed by deterministic test suites.

## Where to Start: Practical Steps to Raise Your Ambition with AI

To translate these architectural concepts into daily practice, execute a systematic five-step operational playbook:

1. **Audit your task log**: Identify isolated micro-tasks representing pure Speed and elevate them to high Altitude by replacing nouns with operational verbs and explicitly defining the goal beyond the goal.
2. **Inject professional Depth**: Apply Felix Rieseberg's 4-step prompt transformation template. Force your model to process raw event streams, relational database schemas, and statistical code rather than accepting high-level text summaries.
3. **Configure tool access**: Deploy Model Context Protocol (MCP) clients to link your local workspace, file system, databases, and issue trackers directly to model execution contexts.
4. **Construct simple agentic loops**: Use direct API calls before reaching for complex, opaque orchestration frameworks. Implement clear Orchestrator-Workers or Evaluator-Optimizer topologies where state transitions and evaluator feedback criteria are explicitly defined in code.
5. **Set unreasonable performance goals**: Assign aggressive targets and implement external unit tests, linters, and compilers to verify environmental ground truth objectively. Operating as a Centaur or Cyborg across the Jagged Frontier transforms frontier models from basic chat assistants into force multipliers for human ambition.

```bash
# Execute an autonomous, evaluation-driven model loop via CLI
claude-code \
  --mcp-config ./mcp_tools.json \
  --prompt "Audit the entire src/ directory. Run pytest, identify failing integration tests, execute dynamic profiling, refactor latency bottlenecks, and verify all tests pass with zero regression." \
  --auto-approve
```

## References

- [How to be more ambitious: A tutorial for humans with models — Felix Rieseberg](https://felixrieseberg.com/how-to-be-more-ambitious-a-tutorial-for-humans-with-models/)
- [Discussion on "How to be more ambitious: A tutorial for humans with models" — Hacker News](https://news.ycombinator.com/item?id=41847190)
- [Math 2.0 — Terence Tao](https://terrytao.wordpress.com/2026/10/10/math-2-0/)
- [Fast — Patrick Collison](https://patrickcollison.com/fast)
- [Building a Practically Useful Theory of Goal Setting and Task Motivation: A 35-Year Odyssey — Edwin A. Locke & Gary P. Latham](https://med.stanford.edu/content/dam/sm/s-spire/documents/PD.locke-and-latham-retrospective%5FPaper.pdf)
- [Building Effective AI Agents — Anthropic](https://www.anthropic.com/engineering/building-effective-agents)
- [Centaurs and Cyborgs on the Jagged Frontier — Ethan Mollick](https://www.oneusefulthing.org/p/centaurs-and-cyborgs-on-the-jagged)
- [What is the Model Context Protocol (MCP)? — Model Context Protocol](https://modelcontextprotocol.io/introduction)