The Law of Conservation of Intelligence

The biggest difference between a small LLM and a big LLM is the amount of reasoning tokens they use to accomplish a task. Often, a Qwen 3.8 27B will spend a long time talking in irrelevant metaphors before producing a piece of code that a DeepSeek V4 Flash Vision will do with far fewer tokens.

The prompt was Write a small Python script that prints the Fibonacci sequence from 1 up to the integer value given in sys.argv[1] (i.e. all Fibonacci numbers <= that value). Return the script in a single code block. with thinking on, max_tokens to 16000, and reasoning_effort unset.

DeepSeek V4 Flash Vision produces ~400 reasoning tokens that get right to the point. The prompt isn't clear about whether to start with 1, 1 or 1, 2 so it resolves it one way and moves on. One illustrative section of Qwen 3.8 27B's reasoning is this part:

Sequence from 1: Could be 1,1,2,3... Usually fib starting 1,1. If they mean 1,2,3,5? "Fibonacci sequence from 1" ambiguous. Many say 1,1,2. Need all Fibonacci numbers <= value. If given 1, print 1? or 1,1? If sequence includes two 1s, all <=1 would print 1 twice? Usually sequence 1,1,2. But "from 1 up to" maybe print 1,2,3,5 (distinct). Need decide. Script could print starting a=1,b=2 to avoid duplicate 1. But Fibonacci sequence commonly: 0,1,1,2... or 1,1,2. If they specifically "from 1" maybe exclude 0 and include 1 once? Need robust? Could include both 1s? If limit=1, printing twice may be weird

A while ago, I read this tweet that made the whole thing clear to me. The evaluation of the context produces an opportunity to perform more computation on the prompt and reach a conclusion.

Kaley Brauer @kaleybrauer

If you ask a frontier LLM a multi-hop reasoning question, e.g., "Who won the Nobel Prize for Chemistry in (1900 + Mozart's age when he died)?", it usually can't answer correctly immediately (no thinking)

BUT if you ask the same question & append 300 dots, suddenly it can answer?

Jul 17, 2026

This may not seem particularly interesting given Chain of thought and the fact that irrelevant seeming reasoning traces work but using the dots makes it all clear that the extra context gives the model more opportunity to run computation.

This is part of why so many benchmarks and announcements are useless. You have all these headline tokens per second, and model success and so on, but the actual wall-clock difference is enormous because of the fact that amount of reasoning varies so much. In some sense, there is a law of conservation of intelligence and you can either get to the result quick or have such a huge working memory that you can work out the answer manually. I think it'll be interesting to see as models grow whether some such property lasts.

Model Outputs

Here are the raw model outputs

DeepSeek V4 Flash Vision

Reasoning

We need answer script. Need comply. Need small Python script prints Fibonacci sequence from 1 up to integer value sys.argv[1], all Fib numbers <= that value. Need return script in single code block. Need perhaps include import sys. Need decide sequence definition: Fibonacci sequence from 1 up. Usually 1, 1, 2, 3, 5... starting with 1,1. Need print all <= n. If n maybe 0? "from 1 up to integer value" all Fibonacci numbers <= value. If value <1? If n=0, maybe none. If n=1, output 1 1? But "from 1" could include 1,1? Need handle. We can implement. Need code block. Keep simple.

Need maybe avoid recursion. Script:

import sys

def main():
    if len(sys.argv) != 2:
        return
    try:
        limit = int(sys.argv[1])
    except ValueError:
        return
    a, b = 1, 1
    while a <= limit:
        print(a)
        a, b = b, a + b

if __name__ == "__main__":
    main()

This prints 1,1. Does "integer value given in sys.argv[1]" include all Fibonacci numbers <= that value. For limit negative? a=1 <= -1 false. OK. Need maybe output space separated? "prints the Fibonacci sequence" Could print each on newline. Fine. Need perhaps if user expected starting from 1 not 0. Good.

Need "Return the script in a single code block." final with code block. Need maybe include shebang? Not necessary. Need perhaps "from 1 up to integer value given" maybe "all Fibonacci numbers <= that value". We can include exactly.

Need ensure sys.argv[1] exists. If not, no output. Good.

Let's craft final.

Answer

import sys

def main():
    if len(sys.argv) != 2:
        return

    try:
        limit = int(sys.argv[1])
    except ValueError:
        return

    a, b = 1, 1
    while a <= limit:
        print(a)
        a, b = b, a + b

if __name__ == "__main__":
    main()

Qwen3.8-27B

Reasoning

We need answer user: Write a small Python script that prints Fibonacci sequence from 1 up to integer value given in sys.argv[1] (i.e. all Fibonacci numbers <= that value). Return script in single code block.

Need produce final only code block. Need consider details: sys.argv[1] exists? Could handle missing? User asks small script. Likely:
import sys
limit=int(sys.argv[1])
a,b=1,1
while a<=limit:
    print(a)
    a,b=b,a+b
But if limit < 1 prints nothing. Sequence from 1: Could be 1,1,2,3... Usually fib starting 1,1. If they mean 1,2,3,5? "Fibonacci sequence from 1" ambiguous. Many say 1,1,2. Need all Fibonacci numbers <= value. If given 1, print 1? or 1,1? If sequence includes two 1s, all <=1 would print 1 twice? Usually sequence 1,1,2. But "from 1 up to" maybe print 1,2,3,5 (distinct). Need decide. Script could print starting a=1,b=2 to avoid duplicate 1. But Fibonacci sequence commonly: 0,1,1,2... or 1,1,2. If they specifically "from 1" maybe exclude 0 and include 1 once? Need robust? Could include both 1s? If limit=1, printing twice may be weird. Let's craft small script:
import sys
try:
 limit=int(sys.argv[1])
except (IndexError, ValueError):
 print("usage: python script.py <limit>", file=sys.stderr); sys.exit(1)
a,b=1,1
while a<=limit:
 print(a)
 a,b=b,a+b
This prints 1 twice if limit>=1? Actually while a<=limit: print 1; a=1,b=2; print 1; a=2,b=3; etc. If limit=1 prints two lines. Could be undesired. If we want unique starting 1: a,b=1,2; while a<=limit: print(a); a,b=b,a+b. Then for limit=1 prints 1. Sequence 1,2,3,5,... which is Fibonacci without duplicate. Many programming challenges "Fibonacci sequence from 1 up to N" expect 1,2,3,5 maybe. Need choose.

User: "prints the Fibonacci sequence from 1 up to the integer value given in sys.argv[1] (i.e. all Fibonacci numbers <= that value)." "all Fibonacci numbers" could mean distinct numbers. Sequence from 1: 1, 2, 3, 5? In standard Fib, F(1)=1,F(2)=1. "all Fibonacci numbers <= value" might include duplicate 1? No, set of numbers. Better start 1,2.

Need return in single code block. Could include error handling but small. Ensure code block only? They say Return the script in a single code block. Final should only code block. Use python. Could be:
import sys

def main():
    if len(sys.argv) != 2:
        raise SystemExit(f"Usage: {sys.argv[0]} <limit>")
    try:
        limit = int(sys.argv[1])
    except ValueError:
        raise SystemExit("Limit must be an integer.")
    a, b = 1, 2
    while a <= limit:
        print(a)
        a, b = b, a + b

if __name__ == "__main__":
    main()

But "small" maybe no main? Either okay. Single code block. Need if limit negative prints nothing. If limit=0 prints nothing. Good.

Could they expect using sys.argv[1] exactly. This works. If no arg, exits. Fine.

Potential issue: If limit is 1, prints 1. Good. If they expected 1,1,2, they might see missing second 1. But phrase "numbers <= that value" suggests values not sequence terms? However "Fibonacci sequence" has duplicate 1 if starting at 1. But many definitions: 1,2,3,5,8... if start with 1 and 2. Let's maybe write comment? But final only code. Could choose a,b=1,1 and handle duplicate? Let's analyze likely test. If user wants "Fibonacci sequence from 1 up to integer value" e.g. sys.argv[1]=10, expected output likely:
1
1
2
3
5
8
or
1
2
3
5
8

Which is more likely? Many simple scripts:
a, b = 1, 1
while a <= n:
 print(a)
 a,b = b,a+b
They say from 1, not 0, so two ones. But if "all Fibonacci numbers <= that value" duplicate not an issue? It's sequence terms, not unique. If limit=1, would print 1 twice, which is weird but mathematically sequence terms. If test checks line count? Unclear.

The instruction: "prints the Fibonacci sequence from 1 up to the integer value given in sys.argv[1] (i.e. all Fibonacci numbers <= that value)." The parenthetical clarifies up to value, all Fibonacci numbers <= value. "numbers" not terms. Starting from 1, the Fibonacci numbers are 1, 2, 3, 5... often in casual context. I lean 1,2.

Need ensure if limit=2, prints 1,2. If a,b=1,1, prints 1,1,2. Maybe too many. If limit=1, "all Fibonacci numbers <= 1" is just 1. So 1,2 better.

Could also print unique by using set? Not needed.

Need final: single code block. No extra text. Ensure no analysis in final.

Answer

```python import sys

def main():

   if len(sys.argv) != 2:
       raise SystemExit(f"Usage: {sys.argv[0]} <limit>")

   try:
       limit = int(sys.argv[1])
   except ValueError:
       raise SystemExit("Limit must be an integer.")

   a, b = 1, 2
   while a <= limit:
       print(a)
       a, b = b, a + b

if __name__ == "__main__":

   main()

```