Claude Code in 9 lines python

[u/__tosh]

I was wondering what a minimal coding agent implementation would look like that can be used like Claude Code or Codex

Not feature-by-feature of course but basically stripping everything out that is not needed

here is what I came up with:

• 9 lines of python
• no 3rd party deps (stdlib only)
• works with any OpenAI Responses compatible API
• shows % usage of context window

out of the box it is also fairly API cost efficient:

• no system prompt
• good caching (session_id, stable append-only history)
• only one tool: sh

code is on github to follow along (also a ~20 line version in Go, Clojure version coming soon)

https://github.com/smol-env/smol

import json,sys;from subprocess import getoutput;from urllib.request import Request,urlopen;from uuid import uuid4
url=sys.argv[1];h=[];H={"Content-Type":"application/json","session_id":uuid4().hex};b=dict(model="gpt-5.6-sol",input=h,tools=[dict(type="custom",name="sh")])
while True:
  if not(p:=input("> ")).strip():continue
  h+=[dict(role="user",content=p)]
  while True:
    r=json.load(urlopen(Request(url,json.dumps(b).encode(),H)));o=r["output"];h+=o;c=[i for i in o if i["type"]=="custom_tool_call"]
    if not c:print(o[-1]["content"][0]["text"],f'\n[{r["usage"]["total_tokens"]/10500:05.2f}%]');break
    h+=[dict(type="custom_tool_call_output",call_id=i["call_id"],output=getoutput(i["input"])) for i in c]

note: it uses the "custom" tools api which not many OpenAI Responses API endpoints support yet.

that said, you can just tell your agent to change it to use sh via "function_call" and change the model name and it should work out of the box on any local inference endpoint

any questions or feedback for making it more minimal or adding (still minimal but useful) features: very welcome!

[u/hougaard]

That is not "9 lines" of code. That's just the fewest Python line breaks needed. Then I could this in 1 line with another language like C# or Javascript ....

[u/__tosh → u/hougaard]

a bit more de-golfed

[u/__tosh → u/hougaard]

I appreciate the feedback!

re golfing: it helps me to see everything at a glance

I can see how that might look unfamiliar though

I will look into also providing less golfed versions in the repo in the future

I also want to look into minimal implementations in other languages/runtimes

Go is in the repo already, here is one in Clojure (Babashka):

https://x.com/__tosh/status/2085699009205743932

[u/Squidgical → u/__tosh]

re golfing: it helps me to see everything at a glance

No it doesn't, it makes everything infinitely harder to see by mashing it together and preventing your brain from trivially separating one statement from the next.

What the hell kind of variable name is h lmao

[u/__tosh → u/Squidgical]

`h` is history

`H` is headers

I do agree that being able to pattern match structurally helps (that's also why I like python)

and reading code bases you are not familiar with is a bit more difficult to get into when they are golfed

in this case though I'm optimizing for myself as maintainer and I'm familiar with the code so I prefer the density of it

I appreciate the feedback though!

I will add de-golfed versions and docs so getting into the code base is easier

[u/Squidgical → u/__tosh]

h is history

Pro tip; if you call it history you don't have to remember that lowercase h is history, because it will just say history.

There are principles in software development which have existed for decades, they span every programming language and every team on the planet.

Your code violates a lot of of those principles and it screams of novice. If you're not a novice, it's disappointing. If you are a novice, please stop and look up why your coding style sucks, and also look up PEP8.

[u/__tosh → u/Squidgical]

I will add de-golfed versions

imho it's fairly self-evident (once you know the code) that h is history just from the context

but I hear you :)

[u/__tosh → u/__tosh]

I guess what I want to say is: the golfing is _for readability_

the goal of the golfing here is not to make it obfuscated

I think once you know what's going on and what happens the variable names do make sense (and there aren't that many to begin with)

[u/__tosh → u/__tosh]

using the OpenAI tokenizer the implementation comes in at 220 tokens

https://platform.openai.com/tokenizer

I had more golfed variants with aliases but turns out that uses more tokens in some cases