It’s super cool how I have come full circle. back in those days, we didn’t have tool calling, reasoning, not even GPT 3.5!

It used code-davinci-002 in a custom Jupyter kernel, a.k.a. the OG codex code completion model. The kids these days probably have not seen the original Codex launch video with Ilya, Greg and Wojciech. If you have time, sit down to watch and realize how far we’ve come since August 2021, airing of that demo 4.5 years ago.

For some reason, I did not even dare to give codex bash access, lest it delete my home folder. So it was generating and executing Python code in a custom Jupyter kernel.

This meant that the conversations were using Jupyter nbformat, which is an array of cell input/output pairs:

{
  "cells": [
    {
      "cell_type": "code",
      "source": "<Input 1>",
      "outputs": [
         ... <Outputs 1>
      ]
    },
    {
      "cell_type": "code",
      "source": "<Input 2>",
      "outputs": [
         ... <Outputs 2>
      ]
    }
  ]
}

In fact, this product grew into TextCortex’s current chat harness over time. After seeing ChatGPT launch, I repurposed icortex in a week into Flask to use text-davinci-003 and we had ZenoChat, our own ChatGPT clone, before Chat Completions was in the API (it took them some months). It did not even have streaming, since Flask does not support ASGI.

As it turns out, nbformat is not the best format for a conversation. Instead of input/output pairs, OpenAI data model used an tree of message objects, each with a role: user|assistant|tool|system and a content field which could host text, images and other media:

{
  "mapping": {
    "client-created-root": {
      "id": "client-created-root",
      "message": null,
      "parent": null,
      "children": ["user-1"]
    },
    "user-1": {
      "id": "user-1",
      "message": {
        "id": "user-1",
        "author": { "role": "user", ... },
        "content": "Hello"
      },
      "parent": "client-created-root",
      "children": ["assistant-1"]
    },
    "assistant-1": {
      "id": "assistant-1",
      "message": {
        "id": "assistant-1",
        "author": { "role": "assistant", ... },
        "content": "Hi"
      },
      "parent": "user-1",
      "children": []
    }
  },
  "current_node": "assistant-1"
}

You will notice that the data model they serve from the API is an enriched version of the deprecating ChatCompletions API. Eg. whereas ChatCompletions role is a string, in OpenAI’s own backend has the author object that can store name, metadata, and other useful stuff for each entity in the conversation.

After reverse engineering it, I copied it to be TextCortex’s new data model, which it still remains, with some modifications.

I thought the tree structure being used to emulate message editing experience was very cool back in the days. OpenAI’s need for human annotation for later training and the user’s need for getting a different output, two birds in one stone.

Now I don’t know what to think of it, since CLI coding agents like Codex and Claude Code don’t have branching, just deleting back to a certain message. A part of me still misses branching in these CLI tools.

When I made icortex,

• we were still 8 months away (May 2023) from the introduction of “tool calling” in the API, or as it was originally called, “function calling”.
• we were 2 years away (Sep 2024) from the introduction of OpenAI’s o1, the first reasoning model.

both of which were required to make current coding agents possible.

In the video above, you can even see the approval [Y/n] gate before executing. I was so cautious, for some reason, presumably because smol-brained model generated the wrong thing 80% of the time. It is remarkable how much it resembles Claude Code, after all this time.

Definition of being too early…

Repo: github.com/textcortex/icortex

Like before tractors and the industrial revolution, 80% of the population had to farm. Once they came, all those jobs disappeared.

So the analogy makes perfect sense. Instead of 30 people tending a field, you just need 1. Instead of 30 software developers, you just need one.

Except that people forget one crucial thing about land: it’s a limited resource.

Unlike land, digital space is vast and infinite. Software can expand and multiply in it in arbitrarily complex ways.

If you wanted the farming analogy to keep up with this, you would have to imagine us creating continent-sized hydroponic terraces up until the stratosphere, and beyond…

Tweet embed disabled to avoid requests to X.

One cannot do these things easily with GitHub now:

• granular control: this agent running in this sandbox can only push to this specific branch. If an agent runs amok, it could delete everybody’s branches and close PRs. GitHub allows for recovery of these, but still inconvenient even if it happens once
• create a bot (exists already), but remove reviewing rights from it so that an employee cannot bypass reviews by tricking the bot to approve
• in general make a distinction between HUMAN and AGENT so that you can create rulesets to govern the relationships in between

The fundamental problem with GitHub is trust: humans are to be trusted. If you don’t trust a human, why did you hire them in the first place?

Anyone who reviews and approves PRs bears responsibility. Rulesets exist and can enforce e.g. CODEOWNER reviews or only let certain people make changes to a certain folder

But the initial repo setup on GitHub is allow-by-default. Anyone can change anything until they are restricted from it

This model breaks fundamentally with agents, who are effectively sleeper cells that will try to delete your repo the moment they encounter a sufficiently powerful adversarial attack

For example, I can create a bot account on GitHub and connect clawdbot to it. I need to give it write permission, because I want it to be able to create PRs. However, I don’t want it to be able to approve PRs, because a coworker could just nag at the bot until it approves a PR that requires human attention

To fix this, you have to bend backwards, like create a @human team with all human coworkers, make them codeowner on /, and enforce codeowner reviews. This is stupid and there has to be another way

Even worse, this bot could be given internet access and end up on a @elder_plinius prompt hack while googling, and start messing up whatever it can in your organization

It is clear that GitHub needs to create a second-class entity for agents which are default low-trust mode, starting from a point of least privilege instead of the other way around

• $20 -> 1x usage
• $100 -> 5x usage
• $200 -> 1̶0̶x̶ 20x usage

As you can see, it’s not growing linearly. This is classic Jensen “the more you buy, the more you save”

But here is the thing. You are not selling hardware like Jensen. You are selling a software service through an API. It’s the worst possible pricing for the category of product. Long term, people will game the hell out of your offering

Meanwhile OpenAI decided not to do that. There is no quirky incentive for buying bigger plans. $200 chatgpt = 10 x $20 chatgpt, roughly

And here is where it gets funny. Despite not having such an incentive, you can get A LOT MORE usage from the $200 OpenAI plan, than the $200 Anthropic plan. Presumably because OpenAI has better unit economics (sama mentioned they are turning a profit on inference, if you are to believe)

Thanks to sounder pricing, OpenAI can do exactly what Anthropic cannot: offer GPT in 3rd party harnesses and win the ecosystem race

Anthropic has cornered itself with this pricing. They need to change it, but not sure if they can afford to do so in such short notice

All this is extremely bullish on open source 3rd party harnesses, OpenCode, Mario Zechner’s pi and such. It is clear developers want options. “Just give me the API”

I personally am extremely excited for 2026. We’ll get open models on par with today’s proprietary models, and can finally run truly sovereign personal AI agents, for much cheaper than what we are already paying!

Originally posted on linkedin

Reason is simple. Most of us are employed. Advent of Code coincides with work time, so you can’t really immerse yourself in a side project.¹

However, Christmas (or any other long holiday without primary duties) is a better time to immerse yourself in a side project.

2025 was the eve of agentic coding. This was the first holiday where I had full credential to go nuts on a side project using agents. It was epic:

Tweet embed disabled to avoid requests to X.

75k lines of Rust later, here is what I’ve built during the first Christmas with agents, using OpenAI Codex

• A full mobile rewrite and port of my Python Instagram video production pipeline (single video production time: 1hr -> 5min)
• Bespoke animation engine using primitives (think Adobe Flash, Manim)
• Proprietary new canvas UI library in Rust, because I don’t want to lock myself into Swift
• Thanks to that, it’s cross platform, runs both on desktop and iOS. It will be a breeze porting this to Android when the time comes
• A Rust port of OpenCV CSRT algorithm, for tracking points/objects
• In-engine font rendering using rustybuzz, so fonts render the same everywhere
• Many other such things

Why would I choose to do it that way? Because I have developed it primarily on desktop where I have much faster iteration speed. Aint nobody got time for iOS compilation and simulator. Once I finished the hard part on desktop, porting to iOS was much easier, and I didn’t lock myself in to Apple

Some of these would have been unimaginable without agents, like creating a UI library from scratch in Rust. But when you have infinite workforce, you can ask for crazy things like “create a textbox component from scratch”

What I’ve built is very similar in nature to CapCut, except that I am a single person and I’ve built it over 1 week

What have you built this Christmas with agents?

I always have a tendency to procrastinate with cosmetics, so I developed a habit to mentally force myself not to care about looks and instead focus on the actual content. Doing the changes I have pulled off in the last 2 hours would have been impossible in pre-LLM era. So I kept the awful default Jekyll Minima theme, and did not spend more thought on it. I had actually went through many different themes in this blog before, and I had switched to Minima precisely because of that: I was spending too much time.

I really like designing things visually. I had interest in typography while studying, and I even went as far to design a font, write all my notes in LaTeX, etc. Then I found out that such skills are not valued in the world, and had no luxury to dwell on such things anymore once I started working.

But now it’s different. When I can do what I want 10 times faster with 10 times less attention, I can just do the design I want. Before I thought it was a flex to use default themes, because it showed a) that the person does not care and b) that they had more important things to do.

Well, now my opinion has changed. In the era where making something look good takes a few hours, using a default theme means something else to me: lack of taste.

For this blog, I just vendored Minima and let gpt-5-codex rip on it. Vendoring pattern is getting more popular with libraries like shadcn, and I expect it to be ever more popular with open source libraries, with AI tools becoming more prevalent.

I don’t expect simple frontend development to be in a good place ever again. I don’t expect anyone to outsource simple static site development to humans anymore, when you can get the exact thing you want at virtually no cost.

Update: Anthropic still doesn’t fully accept AGENTS.md, so I created this: claude-md-symlinker.

Install it once and Claude Code can keep local CLAUDE.md -> AGENTS.md symlinks working for you. No manually creating shim files, no committing Claude-branded files into your repos.

Install using the installer script, or give this page to Claude and ask it to install for you.

curl -fsSL https://github.com/osolmaz/claude-md-symlinker/releases/latest/download/claude-md-symlinker-installer.sh | sh

This will install a Claude hook that will check whenever Claude traverses a certain directory, and do the migration automatically for you.

If you are paranoid about security, ask Claude to check the source code for any issues and install the symlinker from the source.

This post will age like milk, because Anthropic will eventually adopt the company-agnostic AGENTS.md standard.

For those that do not know, AGENTS.md is like robots.txt, but for providing plain text context to any AI agent working in your codebase.

It’s very stupid really. It’s not even worthy of being called a “standard”. The only rule is the name of the file.

Anthropic champions CLAUDE.md, named after their own agent Claude. Insisting on that stupid convention is like Google forcing websites to use googlebot.txt instead of robots.txt, or Microsoft clippy.txt.

Anyway, since this post will become irrelevant very soon, here are some AI-generated instructions on how to migrate your CLAUDE.md files to AGENTS.md.

Why Migrate?

• Open Standard: AGENTS.md is an open standard that works with multiple AI systems
• Interoperability: Maintains backward compatibility through symlinks
• Future-Proof: Not tied to a specific AI platform or tool
• Consistency: Standardizes agent instructions across the codebase

Actual Migration Commands Used

Step 1: Rename Files

The following commands were used to rename existing CLAUDE.md files to AGENTS.md:

# Find all CLAUDE.md files and rename them to AGENTS.md
find . -name "CLAUDE.md" -type f -exec sh -c 'mv "$1" "${1%CLAUDE.md}AGENTS.md"' _ {} \;

Step 2: Update Content

Replace Claude-specific references with agent-agnostic language:

# Update file headers in all AGENTS.md files
find . -name "AGENTS.md" -type f -exec sed -i '' 's/This file provides guidance to Claude Code (claude.ai\/code)/This file provides guidance to AI agents/g' {} \;

Step 3: Update .gitignore

Add these lines to .gitignore to ignore symlinked CLAUDE.md files:

# Add to .gitignore
cat >> .gitignore << 'EOF'

# CLAUDE.md files (automatically generated from AGENTS.md via symlinks)
CLAUDE.md
**/CLAUDE.md
EOF

Step 4: Create Symlink Setup Script

Create utils/setup-claude-symlinks.sh with the following content:

#!/bin/bash

# Script to create CLAUDE.md symlinks to AGENTS.md files
# This allows CLAUDE.md files to exist locally without being committed to git

set -e

echo "Setting up CLAUDE.md symlinks..."

# Change to repository root
cd "$(git rev-parse --show-toplevel)"

# Find all AGENTS.md files and create corresponding CLAUDE.md symlinks
git ls-files | grep "AGENTS\.md$" | while read -r file; do
    dir=$(dirname "$file")
    claude_file="${file/AGENTS.md/CLAUDE.md}"
    
    # Remove existing CLAUDE.md file/link if it exists
    if [ -e "$claude_file" ] || [ -L "$claude_file" ]; then
        rm "$claude_file"
        echo "Removed existing $claude_file"
    fi
    
    # Create symlink
    if [ "$dir" = "." ]; then
        ln -s "AGENTS.md" "CLAUDE.md"
        echo "Created symlink: CLAUDE.md -> AGENTS.md"
    else
        ln -s "AGENTS.md" "$claude_file"
        echo "Created symlink: $claude_file -> AGENTS.md"
    fi
done

echo ""
echo "✓ CLAUDE.md symlinks setup complete!"
echo "  - CLAUDE.md files are ignored by git"
echo "  - They will automatically stay in sync with AGENTS.md files"
echo "  - Run this script again if you add new AGENTS.md files"

Step 5: Run Symlink Setup

Make the script executable and run it:

chmod +x utils/setup-claude-symlinks.sh
./utils/setup-claude-symlinks.sh

Top-Level AGENTS.md Note

Add this note to the main AGENTS.md file:

**Note**: This project uses the open AGENTS.md standard. These files are symlinked to CLAUDE.md files in the same directory for interoperability with Claude Code. Any agent instructions or memory features should be saved to AGENTS.md files instead of CLAUDE.md files.

Directory Structure After Migration

project/
├── AGENTS.md          # Primary agent instructions
├── CLAUDE.md          # Symlink to AGENTS.md (git ignored)
├── utils/
│   └── setup-claude-symlinks.sh  # Symlink setup script
├── backend/
│   ├── AGENTS.md      # Backend-specific instructions
│   └── CLAUDE.md      # Symlink to AGENTS.md (git ignored)
└── apps/
    ├── AGENTS.md      # Frontend-specific instructions
    ├── CLAUDE.md      # Symlink to AGENTS.md (git ignored)
    └── web/
        ├── AGENTS.md  # App-specific instructions
        └── CLAUDE.md  # Symlink to AGENTS.md (git ignored)

Content Update Examples

Before Migration

# CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

After Migration

# AGENTS.md

This file provides guidance to AI agents when working with code in this repository.

Verification Commands

Verify the migration worked correctly:

# Check all AGENTS.md files exist
find . -name "AGENTS.md" -type f

# Verify symlinks are created
find . -name "CLAUDE.md" -type l

# Check symlinks point to correct files
find . -name "CLAUDE.md" -type l -exec ls -la {} \;

# Verify content is agent-agnostic
grep -r "Claude Code (claude.ai/code)" . --include="*.md" | grep AGENTS.md

Maintenance

Adding New AGENTS.md Files

When you add new AGENTS.md files, run the symlink setup script:

./utils/setup-claude-symlinks.sh

Checking Symlink Status

# List all symlinks
find . -name "CLAUDE.md" -type l -exec ls -la {} \;

# Check for broken symlinks
find . -name "CLAUDE.md" -type l ! -exec test -e {} \; -print

Benefits of This Approach

1. Backward Compatibility: Existing tools expecting CLAUDE.md files continue to work
2. Git Clean: CLAUDE.md files are not tracked in version control
3. Automatic Sync: Symlinks ensure CLAUDE.md always matches AGENTS.md
4. Easy Maintenance: Single script handles all symlink creation/updates
5. Open Standard: Future-proof with the open AGENTS.md standard

Troubleshooting

Broken Symlinks

# Remove all CLAUDE.md symlinks and recreate
find . -name "CLAUDE.md" -type l -delete
./utils/setup-claude-symlinks.sh

Permission Issues

# Make sure script is executable
chmod +x utils/setup-claude-symlinks.sh

This migration preserves all existing functionality while adopting the open AGENTS.md standard for better interoperability.

Unfortunately, Claude Code often ignores instructions in CLAUDE.md files to use uv run python instead of plain python commands. Even with clear documentation stating “always use uv”, Claude Code will attempt to run python directly, leading to “command not found” errors in projects that rely on uv for Python environment management.

The built-in Claude Code hooks and environment variable settings also don’t reliably solve this issue due to shell context limitations.

The reason is that Claude (and most other AI models) take time to catch up to such changes, because their learning horizon is longer, up to months to years. Somebody will need to include this information explicitly in the training data.

Until then, we can prevent wasting tokens by mapping python and python3 to uv.

I personally don’t want to map these globally, because a lot of other packages might depend on system installed pythons, like brew packages, gcloud CLI and so on.

Because of that, I map them at the project level, using direnv:

An OK-ish solution: direnv + dynamic wrapper scripts

We can force Claude Code (and any developer) to use uv run python by dynamically creating wrapper scripts in a .envrc file that direnv automatically loads when entering the project directory.

This will override python and python3 to map to uv run python, and also print a nice message to the model:

Use "uv run python ..." instead of "python ..." idiot.

This is probably not the best solution, but it is a solution. Feel free to suggest a better one.

Step 1: Install direnv

# macOS
brew install direnv

# Ubuntu/Debian
sudo apt install direnv

# Add to your shell (bash/zsh)
echo 'eval "$(direnv hook zsh)"' >> ~/.zshrc  # or ~/.bashrc
source ~/.zshrc  # or restart terminal

Step 2: Setup direnv with dynamic wrapper scripts

# Create .envrc file in project root
cat > .envrc << 'EOF'
#!/bin/bash
# Create temporary bin directory for python overrides
TEMP_BIN_DIR="$PWD/.direnv/bin"
mkdir -p "$TEMP_BIN_DIR"

# Create python wrapper scripts
cat > "$TEMP_BIN_DIR/python" << 'INNER_EOF'
#!/bin/bash
echo "Use \"uv run python ...\" instead of \"python ...\" idiot"
exec uv run python "$@"
INNER_EOF

cat > "$TEMP_BIN_DIR/python3" << 'INNER_EOF'
#!/bin/bash
echo "Use \"uv run python ...\" instead of \"python3 ...\" idiot"
exec uv run python "$@"
INNER_EOF

# Make them executable
chmod +x "$TEMP_BIN_DIR/python" "$TEMP_BIN_DIR/python3"

# Add to PATH
export PATH="$TEMP_BIN_DIR:$PATH"
EOF

# Allow direnv to load this configuration
direnv allow

Step 3: Update .gitignore

# Add direnv generated files to .gitignore
echo "# direnv generated files" >> .gitignore
echo ".direnv/" >> .gitignore

Step 4: Update documentation

Add to your CLAUDE.md something like this:

## Python Package Management with uv

**IMPORTANT**: This project uses `uv` as the Python package manager. ALWAYS use `uv` instead of `pip` or `python` directly.

DO NOT RUN:

```bash
python my_script.py
# OR
chmod +x my_script.py
./my_script.py
```

INSTEAD, RUN:

```bash
uv run my_script.py
```

### Key uv Commands

- **Run Python code**: `uv run <script.py>` (NOT `python <script.py>`)
- **Run module**: `uv run -m <module>` (e.g., `uv run -m pytest`)
- **Add dependencies**: `uv add <package>` (e.g., `uv add requests`)
- **Add dev dependencies**: `uv add --dev <package>`
- **Remove dependencies**: `uv remove <package>`
- **Install all dependencies**: `uv sync`
- **Update lock file**: `uv lock`
- **Run with specific package**: `uv run --with <package> <command>`

How It Works

1. direnv automatically loads .envrc when you cd into the project directory
2. .envrc dynamically creates executable wrapper scripts in .direnv/bin/
3. Scripts display a helpful message and redirect to uv run python
4. .direnv/bin/ is prepended to PATH, overriding system python commands
5. Works for any shell session in the directory (Claude Code, terminal, IDE)

To see if it works:

cd your-project/
python -c "print('Hello World')"  # Shows message, uses uv
python3 --version                 # Shows message, uses uv

Let me know if this doesn’t work for you, or if you find a better solution.

It’s not an overstatement that my life has drastically changed since then. I can’t post or blog anything anymore, because I am busy working every day on ideas, at TextCortex, and on side projects. I now sleep regularly 1-2 hours less than I used to and my sleep schedule has shifted around 2 hours.

But more importantly, I feel exhilaration that I have never felt as a developer before. I just talk to my computer using a speech to text tool (Wispr Flow), and my thoughts turn into code close to real time. I feel like I have enabled god mode IRL. We are truly living in a time where imagination is the only remaining bottleneck.

Things I have implemented using Claude Code

TextCortex Monorepo

The most important contribution, I merged our backend, frontend and docs repos into a single monorepo in less than 1 day, with all CI/CD and automation. This lets us use our entire code and documentation context while triggering AI agents.

We can now tag @claude in issues, and it creates PRs. Non-developers have started to make contributions to the codebase and fix bugs. Our organization speed has increased drastically in a matter of days. I will write more about this in a future post.

JSON-DOC TypeScript renderer

JSON-DOC is a file format we are developing at TextCortex. I implemented the browser viewer for the format in 1 workday, in a language I am not fluent in. It was a rough first draft, but the architecture was correct and our frontend team could then take it over and polish it. Without Claude Code, I predict it would have taken at least 2-3 weeks of my time to take it to that level.

Claude Code PR Autodoc Action

We are not using this anymore, but it’s a GitHub Action that triggers in every PR and adds documentation about that PR to the repo.

Claude Code Sandbox

Still work-in-progress, but it is supposed to give you an OpenAI Codex like experience with running Claude Code locally on your own machine. We have big plans for this.

TextCortex Agentic RAG implementation

The next version of our product, I revamped our chat engine completely to implement agentic RAG. Since our frontend had long running issues, I had to recreate our chat UI from scratch, again in 1 day. Will be rolled out in a few weeks, so I cannot write about it yet.

Fixed i18n

I had a system in mind for auto-translating strings in a codebase for 2 years, when GPT-4 came out. I finally implemented that in 1 day. We had previously used DeepL which did some really stupid mistakes like translating “Disabled” (in the computer sense) as “behindert” in German, which means r…ded, or “Tenant” (enterprise software) as “Mieter” (renter of a real estate). The new system generates a context for each string based on the surrounding code, which is then used to translate the string to all the different languages. There is truly no point in paying for a SaaS for i18n anymore, when you can automate it with GitHub Actions and ship it statically.²

Tackling small-to-mid-size tasks without context switching

Perhaps the most important effect of agentic development is that it lets you do all the things you wanted to, but couldn’t before, because it was too big of a context switch.

There are certain parts of a codebase that require utmost attention, like when you are designing a data model, the API endpoint schemas, and so on. Mostly backend. But once you know your backend is good enough, you can just rip away on the frontend side with Claude Code, because you know your business data and logic is safe.

I have finished so many of these that it would make this post too long. To give one example, I implemented a Discord bot that we can use to download whole threads, so that we can embed it in the monorepo or create GitHub issues automatically.

Side projects

My performance on my side projects has also increased a lot. I am able to ship in 1 weekend day close to 2 weeks worth of dev-work. Thanks to Claude Code, I was able to ship my new app Horse. It’s like an AI personal trainer, but it only counts your push-ups for now. But even that was a complex enough computer vision task.

I had previously only written the Python algo for detecting push-ups. Claude Code let me develop the backend, frontend and the low-level engine in Rust, over the course of 2-3 weekends.

I knew nothing about cross-compiling Rust code to iOS, yet I was able to do the whole thing, FFI and all, in 20 minutes, which worked out of the box. Important takeaway: AI makes it incredibly easy to port well-tested codebases to different languages. I predict an increased rate of Rust-ification of open source projects.

You can see more about it on my sports Instagram here.

It’s all about completing the loop

Agentic workflows work best when you have a good verifier (like tests) which lets you create a good feedback loop. This might be the compiler output, a Playwright MCP server, running pytest, spinning up a local server and making a request, and so on.

Once you complete the loop, you can just let AI rip on it, and come back to a finished result after a few minutes or hours.

Swearing at AI

I have developed a new and ingrained habit of swearing at Claude Code, in the past couple of weeks. I frequently call it “idiot”, “r…d”, “absolute f…g moron” and so on. With increasing speed comes increasing impatience, and frustration when the agent does not get something despite having the right context.

I think there is something deeply psychological about feeling these kind of emotions towards AI. I know it’s an entity that does not retain memory or learn as a human does, but I still insult it when it fails at a task. I feel like it mostly works, but I have not done any scientific experiments to prove it.

The empathic reader should be aware that emotional reactions to AI reveal more about one’s own psychological state than the AI’s.

On Claude Code skeptics

Claude Code is a great litmus test to detect whoever is a deadweight at a company. If your employees cannot learn to use Claude Code to do productive work, you should most likely fire them. It’s not about the product or Anthropic itself, but the upcoming agentic development paradigm. Dario Amodei was not bluffing when he said that a white collar bloodbath is coming.

I have since then introduced multiple people to Claude Code, all good developers. All of them were initially skeptical, but the next day all of them texted me “wow”-like messages. The fire is spreading.

The 100 USD plan was initially the main obstacle to people trying it out, but now it’s available in the 17 USD plan, so I expect to see very rapid adoption in the following months.

I got done in 47 days more work than I previously did in 6-12 months. I am curious how TextCortex will look in 6 months from now.

(Clicking will start the video around the 1hr mark, the part that is relevant to this post.)

According to Sholto and Trenton, the following have been largely “solved” by now:

• Advanced math/programming:
  • “Math and competitive programming fell first.” (Sholto)
• Routine online interactions:
  • “Flight booking is totally solved.” (Sholto)
  • Successfully “planning a camping trip,” navigating complicated websites. (Trenton)

And below are their predictions for what will be solved by next year, around May 2026:

• Reliable web/software automation:
  • Photoshop edits with sequential effects: “Totally.” (Sholto)
  • Handling complex site interactions (e.g., managing cookies, navigating tricky interfaces): “If you gave it one person-month of effort, then it would be solved.” (Sholto)

And below are what they predict will probably not be solved by next year:

• Fully autonomous, high-trust tasks:
  • “I don’t think it’ll be able to autonomously do your taxes with a high degree of trust.” (Sholto)
• Generalized tax preparation:
  • “It will get the taxes wrong… If I went to you and I was like, ‘I want you to do everyone’s taxes in America,’ what percentage of them are you going to fuck up?” (Sholto)
• Models’ self-awareness of its own reliability and confidence:
  • “The unreliability and confidence stuff will be somewhat tricky, to do this all the time.” (Sholto)

I interpret this and the rest of the interview as follows:

The labs can now “solve”¹ any white-collar task or job segment if they put their resources into it. From now on, it is a question of how much it would pay off.

In other words, if the labs think it will make more money to automate accounting (or any other task), then they will create benchmarks for that and start optimizing. Until now, they have mostly been optimizing for software engineering², because of high immediate payoff.

Below are some job segments that I predict to be affected first (not Sholto or Trenton):

• Marketing & copywriting: actually the first segment that already fell. Many AI companies (including TextCortex) was initially focused on this segment. Automation in this sector will increase even more in the upcoming years.
• Customer service & support: many countries where this is outsourced to, like India, will be affected.
• Data entry, bookkeeping & accounting tasks: while it is a dream to automate bookkeeping, accounting, taxes, etc. it will most likely fall last due to regulations and low margin for fuckups.
• Paralegal & contract-review tasks: Many companies popped up to target the legal system. Current law forbids automated lawyering in the US and most of the world. It will eventually fall as well, starting first with paralegal tasks, advisory services, etc.
• Internal IT & systems administration: will be automated the fastest, because it is being optimized for under the software engineering umbrella.
• Real estate & insurance processing: related companies will see that they are able to save a lot of money with AI. There will be a lot of competitive pressure in every country once the first few players are successfully automate their processes. These will most likely be smaller players, who will disrupt incumbents.
• Product/project management (routine parts): cue recent Microsoft layoffs³, ending 600k comp. product manager positions. It is already happening, and will only accelerate.

Object Class: Euclid

Special Containment Procedures: SCP-3434 cannot be fully contained due to its diffuse nature and integration into civilian infrastructure. Foundation agents embedded within Istanbul’s Transportation Coordination Center (UKOME) are to monitor taxi activity patterns for anomalous behavior spikes. Mobile Task Force ████ has been assigned to investigate and neutralize extreme manifestations within SCP-3434.

Individuals exhibiting temporal disorientation after utilizing taxi services in Istanbul should be administered Class-B amnestics and monitored for 72 hours post-incident. Under no circumstances should Foundation personnel utilize SCP-3434 instances for transportation unless authorized for testing purposes.

Description: SCP-3434 is a defensive superorganism manifesting as a collective consciousness within approximately 17,000 taxi vehicles operating in Istanbul, Turkey. Individual taxis display coordinated behaviors atypical for independently operated vehicles, functioning as a distributed neural network despite lacking any detectable communication infrastructure.

SCP-3434 exhibits three primary anomalous properties:

1. Temporal Distortion: Passengers experience significant time dilation upon entering affected vehicles. Discrepancies between perceived and actual elapsed time range from minutes to several hours, with no correlation to distance traveled or traffic conditions. GPS data from affected rides consistently shows corruption or retroactive alteration.

2. Economic Predation: The collective demonstrates uncanny ability to extract maximum possible fare from each passenger through coordinated deception, including meter “malfunctions,” route manipulation, and inexplicable knowledge of passenger financial status. Credit card readers experience a ████ failure rate exclusively for non-local passengers.

3. Territorial Defense: SCP-3434 displays extreme hostility toward competing transportation services. Since 2011, all attempts by ridesharing platforms to establish operations have failed due to coordinated interference including simultaneous vehicle failures, GPS anomalies affecting only competitor vehicles, and physical blockades formed with millisecond precision.

Incident Log 3434-A: On 14/09/2024, Agent ████ ████ was assigned to investigate temporal anomalies reported in the Beyoğlu district. Agent ████ entered taxi license plate 34 T ████ at 14:22 local time for what GPS tracking indicated would be a 12-minute journey to Taksim Square.

Agent ████ emerged at 14:34 local time at the intended destination. However, biological markers and personal chronometer readings indicated Agent ████ had experienced approximately 8 months of subjective time. Physical examination confirmed accelerated aging consistent with temporal displacement. Agent exhibited severe psychological distress and no memory of the elapsed period.

The taxi driver, when questioned, displayed no anomalous knowledge and insisted the journey had taken “only 15 minutes, very fast, no traffic.” The meter showed a fare of ████, approximately 40 times the standard rate. Driver claimed this was “normal price, weekend rates.”

Post-incident analysis of the taxi revealed no anomalous materials or modifications. The vehicle continues to operate within the SCP-3434 network without further documented incidents.

Interview Log:

Interviewed: ███████ (Driver of taxi license plate 34 T ████)

Dr. ████: How long have you been driving this route?

███████: Route? What route? The city tells us where to go.

Dr. ████: The city?

███████: You wouldn’t understand. You’re not connected. But we all hear it. Every corner, every passenger, every lira. We are Istanbul, and Istanbul is us.

Dr. ████: Can you elaborate on-

███████: Your hotel is 20 minutes away. It will take us an hour. The meter is broken. Only cash.

Addendum 3434-1: Research into historical records reveals references to unusual taxi behavior in Istanbul dating back to 1942, coinciding with the introduction of the first motorized taxi services. The phenomenon appears to have evolved in complexity with the city’s growth.

Addendum 3434-2: Foundation economists estimate SCP-3434’s collective annual revenue exceeds ████ million Turkish Lira, with 0% reported to tax authorities. Attempts to audit individual drivers result in temporary disappearance of all documentation and the spontaneous malfunction of all electronic devices within a 10-meter radius.

Note from Site Director: “Under no circumstances should personnel attempt to ‘outsmart’ SCP-3434 by pretending to be locals. They already know. They always know.”

I am on vacation, so here is a little bit of fun with some grounded fiction.

Since Claude Code is envisioned to be a basic Unix utility, albeit a very smart one, it is very easy to use it in GitHub Actions. The action is very simple:

• It runs after a pull request is merged.
• It uses Claude Code to generate a documentation for the pull request.
• It creates a new pull request with the documentation.

This is super useful, because it saves context about the repo into the repo itself. The documentation generated this way is very useful for not only humans, but also for AI agents. A future AI can then learn about what was done in a certain PR, without looking at Git history, issues or PRs. In other words, it lets you automatically break GitHub’s walled garden, using GitHub’s native features ¹.

Installation

1. Save your ANTHROPIC_API_KEY as a secret in the repo you want to install this action. You can find this page in https://github.com/<your-username-or-org-name>/<your-repo-name>/settings/secrets. If you have already installed Claude Code in your repo by running /install-github-app in Claude Code, you can skip this step.
2. Save the following as .github/workflows/claude-code-pr-autodoc.yml in your repo:

name: Auto-generate PR Documentation

on:
  pull_request:
    types: [closed]
    branches:
      - main

jobs:
  generate-documentation:
    # Only run when PR is merged and not created by bots
    # This prevents infinite loops and saves compute resources
    if: |
      github.event.pull_request.merged == true &&
      github.event.pull_request.user.type != 'Bot' &&
      !startsWith(github.event.pull_request.title, 'docs: Add documentation for PR')
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
      id-token: write

    steps:
      - uses: textcortex/claude-code-pr-autodoc-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

There are bunch of parameters you can configure, like minimum number of diff lines that will trigger the action, or the directory where the documentation will be saved. To learn about how to configure these parameters, visit the GitHub Action repo itself: textcortex/claude-code-pr-autodoc-action.

Usage

After you merge a PR, the action will automatically generate documentation for it and open a new PR with the documentation. You can then simply merge this PR, and the documentation will be added to the repo, by default in the docs/prs directory.

Thoughts on Claude Code

I was curious why Anthropic had not released an agentic coding app on Claude.ai, and this might be the reason why.

The main Claude Code action is not limited to creating PR documentation. You tag @claude, in any comment, and Claude Code will answer questions or implement the changes you ask for.

While OpenAI and Google is busy creating sloppy chat UXs for agentic coding (Codex and Jules) and forcing developers to work on their site, Anthropic is taking Claude directly to the developers’ feet and integrate Claude Code into GitHub.

Ask any question in a GitHub PR, and Claude Code will answer your questions, implement requested changes, fix bugs, typos, styling issues.

You don’t need to go to code Codex or Jules website to follow up on your task. Why should you? Developer UX is already “solved” (well yes but no).

Anthropic bets on GitHub, what already works. That’s why they have probably already won developers.

The only problem is that it costs a little bit too much for now.

In the long run, I am not sure if GitHub will be enough for following up async agentic coding tasks in parallel. Anthropic might soon launch their own agentic coding app. GitHub itself might evolve and create a better real-time chat UX. But unless that UX really blows my mind, I will most likely just hang out at GitHub. If you are an insider, or you know what Anthropic is planning to do, please let us know in the HN comment section.

claude-code-pr-autodoc-action was developed by me, 80% using Claude Code and 20% using Cursor with Claude Opus 4.

There was a 2-year old tech debt at TextCortex backend. Resolving it required a major refactor that we wanted to do since one year. I finally paid that tech debt 2 weeks ago, by working a cumulative of 24 hours over 2 days, creating a diff of 5-6k lines of Python code and 90 commits over 105 files.

The result:

• No more request latencies or dropped requests.
• Much faster responses.
• 50% reduction in Cloud Run costs.
• Better memory and CPU utilization.
• Faster startup times.

I’ve broken some eggs while making this omelette—bugs were introduced and fixed. I could finish the task because I had complete code ownership and worked over the weekend without blocking other people. Stuff like this can only happen in startups, or startup-like environments.

Credit also goes to our backend engineer Tugberk Ayar for helping stress testing the new code.

This happened to me too many times: User experiences a bug with an object. Their first instinct is to delete it, and create a new one. They report it. I cannot reproduce and fix it.

If you have a car and it stops working, you don’t throw it in the trash and then call the service to fix it. But when it comes to software, which has virtually zero cost of creation, this behavior somehow becomes widespread.

This is similar to other user behavior like smashing the mouse and keys when a computer gets stuck. It is physically impossible for such an action to speed up a digital process, but many of us instinctively do it.¹ Deleting to fix is a similar behavior, which I suspect got ingrained by crappy Microsoft software. The default way of fixing Windows machines is to “format the disk”, and reinstalling Windows. Nobody asks, “why do I have to start from scratch?”. The “End User” deletes to fix by default, because the End User does not understand. “Have you tried turning it off and on again?”

The concept of “Mechanical Sympathy” is relevant: having an understanding of how a tool works, being able to feel inside the box. We can extend this to “Developer Sympathy”: having an understanding of how a software was developed, how it changes over time, how it can break, how it can be fixed.

Any troubleshooting must be done in a non-destructive way. When a user deletes an object, two things can happen: it is hard-deleted, which makes the issue impossible to reproduce. If it is instead soft-deleted, it might be restored, but developers will mostly not bother, depending on the issue.

The users cannot be expected to care either. Their time is valuable. They deserve things that “just work”. So we need to come up with other workarounds:

• Everything should be soft-deleted by default in non-sensitive contexts, and should be easy to restore.
• Any reporting form should include instructions to warn the user against deleting.
• Even better, the reporting should happen through an internal system, and should automatically block deletion once a ticket is created.

The thing about serious exercise, be it strength training, running, stretching, and so on, is that you are pushing your body beyond its limits. This is called overload. If you do this over a long term period, it is called progressive overload. This is what gives you real power, real speed, ability to do middle splits, and so on.

When you start with an intention to do serious exercise, and you immediately start loading heavily without warming up, you will get injured very quickly and have to take days or weeks of break.

For example, if you directly jump at the heaviest dumbbells you can lift and start doing bicep curls the moment you get to the gym, you will destroy your wrists, elbows, and/or shoulders. You will not realize it immediately. After a few weeks or months, you will start feeling pain, and will have to stop training altogether.

A common thing about noobs who injure themselves early on is that they have fierce willpower, but they don’t listen to their bodies, and they don’t have a good understanding of their current capabilities. They have an idea of where they want to be, and they are prepared to push towards it. But because they are impatient, don’t have good mind-body connection, and don’t know how to plan for long-term progress, they push themselves too far too fast.²

Being able to sustain injury-free long-term practice is a skill in itself, and perhaps the most underrated among non-professional gym-goers and athletes. There is no fancy Latin/Greek name for it, like there is for other things like cardio, plyometrics, hypertrophy, and so on. A crucial idea is missing from mainstream fitness.

Therefore, I coin the term and define it here:

Parathletics: The practices that let you successfully sustain injury-free long-term practice of a physical activity.

The word comes from Greek παρά (para-) meaning “beside/alongside” and ἀθλητικός (athlētikós) meaning “athletic”, “relating to an athlete”³.

Two main parathletic practices are warmup and cooldown.

Before starting a workout, warm up your body by moving your every joint, from the neck to the toes, through its range of motion and increase the blood flow to your muscles. If you plan to do heavy loads, build up to them with lighter weights first.

After finishing a workout, cool down your body by stretching every joint and muscle group, and especially the ones you just trained. The more hardcore your workout, the more you need to stretch.

Skipping these will result in injury, decrease in mobility, and delay in reaching your goals.

Dwarkesh: Even when you have working agents, even when you have things that can do remote work for you, with all the compliance and with all the inherent bottlenecks, is that going to be a big bottleneck, or is that going to move past pretty fast?

Satya: It is going to be a real challenge because the real issue is change management or process change. Here’s an interesting thing: one of the analogies I use is, just imagine how a multinational corporation like us did forecasts pre-PC, and email, and spreadsheets. Faxes went around. Somebody then got those faxes and did an interoffice memo that then went around, and people entered numbers, and then ultimately a forecast came, maybe just in time for the next quarter.

Then somebody said, “Hey, I’m just going to take an Excel spreadsheet, put it in email, send it around. People will go edit it, and I’ll have a forecast.” So, the entire forecasting business process changed because the work artifact and the workflow changed.

That is what needs to happen with AI being introduced into knowledge work. In fact, when we think about all these agents, the fundamental thing is there’s a new work and workflow.

For example, even prepping for our podcast, I go to my copilot and I say, “Hey, I’m going to talk to Dwarkesh about our quantum announcement and this new model that we built for game generation. Give me a summary of all the stuff that I should read up on before going.” It knew the two Nature papers, it took that. I even said, “Hey, go give it to me in a podcast format.” And so, it even did a nice job of two of us chatting about it.

So that became—and in fact, then I shared it with my team. I took it and put it into Pages, which is our artifact, and then shared. So the new workflow for me is I think with AI and work with my colleagues.

That’s a fundamental change management of everyone who’s doing knowledge work, suddenly figuring out these new patterns of “How am I going to get my knowledge work done in new ways?” That is going to take time. It’s going to be something like in sales, and in finance, and supply chain.

For an incumbent, I think that this is going to be one of those things where—you know, let’s take one of the analogies I like to use is what manufacturers did with Lean. I love that because, in some sense, if you look at it, Lean became a methodology of how one could take an end-to-end process in manufacturing and become more efficient. It’s that continuous improvement, which is reduce waste and increase value.

That’s what’s going to come to knowledge. This is like Lean for knowledge work, in particular. And that’s going to be the hard work of management teams and individuals who are doing knowledge work, and that’s going to take its time.

Dwarkesh: Can I ask you just briefly about that analogy? One of the things Lean did is physically transform what a factory floor looks like. It revealed bottlenecks that people didn’t realize until you’re really paying attention to the processes and workflows.

You mentioned briefly what your own workflow—how your own workflow has changed as a result of AIs. I’m curious if we can add more color to what will it be like to run a big company when you have these AI agents that are getting smarter and smarter over time?

Satya: It’s interesting you ask that. I was thinking, for example, today if I look at it, we are very email heavy. I get in in the morning, and I’m like, man my inbox is full, and I’m responding, and so I can’t wait for some of these Copilot agents to automatically populate my drafts so that I can start reviewing and sending.

But I already have in Copilot at least ten agents, which I query them different things for different tasks. I feel like there’s a new inbox that’s going to get created, which is my millions of agents that I’m working with will have to invoke some exceptions to me, notifications to me, ask for instructions.

So at least what I’m thinking is that there’s a new scaffolding, which is the agent manager. It’s not just a chat interface. I need a smarter thing than a chat interface to manage all the agents and their dialogue.

That’s why I think of this Copilot, as the UI for AI, is a big, big deal. Each of us is going to have it. So basically, think of it as: there is knowledge work, and there’s a knowledge worker. The knowledge work may be done by many, many agents, but you still have a knowledge worker who is dealing with all the knowledge workers. And that, I think, is the interface that one has to build.

If you got confused for a second there like me, Lean here is not referring to the open source proof assistant but lean manufacturing.

Whereas it is nice to dream, the actual sentiment on Microsoft Copilot and AI integration in Microsoft Office is along the following lines:

I have written about this in a previous post:

There is going to be an AI-native “Microsoft Office”, and it will not be created by Microsoft. Copilot is not it, and Microsoft knows it. Boiling tar won’t turn it into sugar.