The AI Success Equation

TL;DR

Why do some people consistently get good results with AI while others don’t? It comes down to three factors: knowledge, context, and tools. They multiply, not add. If any one is missing, the probability of success collapses.

• Humans: Limited in knowledge, but rich in context (through shared understanding) and with practically unlimited access to tools.
• AIs: Vast in knowledge, but depend on explicit context and have narrow tool access.

The difference between getting production-ready code and hallucinated nonsense isn’t luck or skill - it’s understanding that in the AI era, context is the bottleneck.

Motivation

Some people claim that AI means the end of all jobs and humans are doomed to be replaced by machines and collect universal basic income. Others dismiss it as hype and vaporware.

I stand somewhere different: I believe this technology is real, here to stay, and transformative — but only if we understand what actually drives success with these systems.

For a while, I’ve been reflecting on a simple question:

Why do some people consistently get good results with AI while others don’t?

Some developers get production-ready code that ships to thousands of users, while others get hallucinated nonsense that won’t even compile. Some teams automate away hours of grunt work, while others struggle to get even basic answers. What makes the difference?

It’s not about being “good with computers” or having access to the latest models. Something more fundamental is at play — I believe it’s an entirely different skillset.

After countless hours experimenting with models, building AI agents, coding with AI editors, using the latest CLIs, and helping others get the most out of AI tools, I arrived at a straightforward equation that captures my mental model for the probability of success.

This article is my attempt to share that framework.

The equation

Imagine someone gives you a task. What determines whether you succeed? We can break it down into three main factors:

1. Knowledge (K): what you already know. This includes domain expertise, learned skills, past experiences, and accumulated wisdom.
2. Context (C): information about this specific task. The who, what, when, where, and why that turns a generic request into an actionable one.
3. Tools (T): what you can use to get it done. Instruments, software, processes, collaborators, or your ability to invent new solutions.

After thinking about how these factors interact with each other, I would say that the probability of success is the product of these factors:

p = K × C × T

Different types of tasks require different balances of these factors. It’s unlikely that an experienced plumber could fix a leak without the right tools, while a lawyer would hardly solve a case without legal knowledge and diving into the case context. This leads to the complete equation:

p = K^α × C^β × T^γ

The exponents are used to adjust the importance of each factor for each type of task, with α, β, γ ≥ 0 and α + β + γ = 1. Check the interactive visualizer below to see how the equation works.

Multiplication matters. You can’t compensate for missing context with more knowledge or better tools. A surgeon with perfect training and vast experience still fails if they don’t know which procedure to perform or have access to patient information. Similarly, AI with vast knowledge fails on vague prompts like “Deploy failed. Fix it!” without environment details, logs, or recent changes.

Humans × AI

The same three factors (knowledge, context, and tools) apply to both humans and AIs, but they manifest in very different ways.

Human experts still outperform AIs when you consider knowledge, context, and tools together. At the same time, AIs already surpass the average human on raw knowledge. As models improve, success will hinge less on adding knowledge and more on supplying precise context and access to the right tools.

The result: Humans usually struggle with knowledge, which is why education takes years. AIs struggle with context, which is why prompt (or context) engineering exists.

AI Agents

If you’ve tried to build AI agents, this framing is nothing new: Agents are a product of knowledge, context, and tools.

Here is a simple example of an AI agent in Next.js using the Vercel AI SDK:

// app/api/agent/route.ts — Next.js (Vercel AI SDK)
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';
import { z } from 'zod';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = await streamText({
    model: openai('gpt-4o-mini'), // knowledge
    system: 'You are a helpful agent. Use tools when needed.', // context
    messages, // context
    tools: { // tools
      getWeather: { // tool name
        description: 'Get current weather for a city', // tool description
        parameters: z.object({ // tool parameters
          city: z.string().min(1, 'city is required'),
          unit: z.enum(['metric', 'imperial']).default('metric'),
        }),
        // tool execution
        execute: async ({ city, unit }) => {
          const res = await fetch(`https://example.com/api/weather?city=${encodeURIComponent(city)}&unit=${unit}`);
          if (!res.ok) throw new Error('weather fetch failed');
          const data = await res.json();
          return `${data.temp}°${unit === 'metric' ? 'C' : 'F'} and ${data.description} in ${city}`;
        },
      },
    },
  });

  return result.toAIStreamResponse();
}

Applying the equation

Let’s see the equation in action with a debugging scenario:

Before (poor context):

Almost no information: which deploy? what error? what environment?

After (good context, structured):

Good context more than doubles the odds of success—from 36% to 88%. The same expert, same tools; clear context transforms a likely struggle into a near-win.

Why do we neglect context

We neglect context because we carry it invisibly. Our assumptions, mental models, and shared history feel so obvious that we forget others (or AIs) don’t share them.

David Foster Wallace captured this beautifully in his 2005 commencement speech at Kenyon College:

Illustration generated by GPT-5

Context is our water. It’s so fundamental to how we navigate the world that we don’t even notice it. We assume others share our mental environment: our cultural references, our technical background, our immediate situation. But like those fish, we’re often unaware of the medium we’re swimming in.

On top of that, context feels like overhead. Typing “Deploy failed. Fix it!” feels efficient, even though it guarantees multiple back-and-forths later.

These shortcuts work (somewhat) in human-to-human interaction, because we’re good at inferring context from tone, body language, and shared experience. But with AI, the problem gets amplified—we’re communicating with something that doesn’t share our water.

Another reason is our fundamental misunderstanding of how models work:

What I find endlessly fascinating:

Some engineers really can’t seem to grasp that LLMs are non-deterministic and how to build software taking that into account.

For others it immediately clicked, but for some it seems like there’s a real mental barrier to accept it.

— Thorsten Ball (@thorstenball) August 14, 2025

LLMs have quirks that make context essential:

• Nondeterminism: The same prompt can yield different outputs. Good context narrows the range of possible answers, reducing randomness.
• Knowledge cutoffs: Models don’t know anything past their training date. Explicit context about versions, updates, or recent changes patches that gap.
• Hallucinations: When missing details, models make things up with confidence. Rich context grounds them, leaving less room to fabricate.

All three quirks share the same fix: clear, structured context turns uncertain guesses into reliable solutions.

The rise of context engineering

AI has fundamentally shifted what skills matter. In the pre-AI era, success required accumulating knowledge and acquiring better tools. Now, with models that already possess vast knowledge and expanding tool access, context engineering has emerged as the critical skill.

Tobi Lütke captured this shift perfectly:

I really like the term “context engineering” over prompt engineering.

It describes the core skill better: the art of providing all the context for the task to be plausibly solvable by the LLM.

— tobi lutke (@tobi) June 19, 2025

Context engineering is becoming as fundamental as programming was in the software era. Just as developers learned to structure code, debug systems, and design architectures, we now need to learn how to:

• Structure information for AI consumption
• Anticipate missing context that humans take for granted
• Design context frameworks that scale across different tasks and domains
• Debug context gaps when AI outputs fall short

The professionals who master context engineering will have the same advantage early programmers had: they’ll be able to reliably harness the most powerful tools of their era while others struggle with inconsistent results.

Practical guide

Context engineering is about providing all the context needed to make a task plausibly solvable by the LLM. A well-structured prompt includes:

Diagram from Advanced Prompt Engineering by Anthropic

1. Task context - The specific situation and background
2. Tone context - How the AI should communicate
3. Background data, documents, and images - Relevant information
4. Detailed task description & rules - Clear, specific instructions
5. Examples - Concrete demonstrations of expected output
6. Conversation history - Previous relevant interactions
7. Immediate task description or request - The current specific request
8. Thinking step by step / take a deep breath - Breaking down complex problems
9. Output formatting - How results should be structured
10. Prefilled response (if any) - Starting the AI’s response pattern

Notice how some of these components make no sense for us humans, they sound completely obvious or even redundant. You wouldn’t tell a colleague “you are a career coach named Joe” or “you should respond in a friendly customer service tone” because humans infer context naturally.

This kind of context is precisely where AI shines: when given these explicit details that humans take for granted, AI can process vast amounts of structured context and maintain perfect attention to every specified requirement.

Conclusion

The task-solving equation highlights the shift of the AI era. Success no longer hinges on accumulating more knowledge or better tools. Those are increasingly commoditized. What’s scarce is the ability to provide rich, explicit context.

Humans succeed despite limited knowledge because we’re rich in context and adaptable with tools. AIs succeed only when we deliberately supply the missing context. Every assumption, every nuance, every artifact matters.

As Guillermo Rauch observed:

Imagine success being determined purely based on the quality of your thoughts. That’s the promise of AI

— Guillermo Rauch (@rauchg) August 15, 2025

The quality of your thoughts (expressed through clear context) now determines success.

Next time you give a task to an AI (or a teammate), ask yourself: Does it have enough knowledge? Did I give it enough context? Does it have access to the right tools?