Code for Cats

The other day I read a post entitled “Opus 4.5 is going to change everything”. The gist was with Claude Opus 4.5 it’s no longer necessary to review code.

I have a vague idea, but you are right – I do not know how the applications are actually assembled. Especially since I don’t know Swift at all.

This used to be a major hangup for me. I couldn’t diagnose problems when things went sideways. With Opus 4.5, I haven’t hit that wall yet—Opus always figures out what the issue is and fixes its own bugs.

The real question is code quality. Without understanding how it’s built, how do I know if there’s duplication, dead code, or poor patterns? I used to obsess over this. Now I’m less worried that a human needs to read the code, because I’m genuinely not sure that they do.

Why does a human need to read this code at all? I use a custom agent in VS Code that tells Opus to write code for LLMs, not humans. Think about it—why optimize for human readability when the AI is doing all the work and will explain things to you when you ask?

What you don’t need: variable names, formatting, comments meant for humans, or patterns designed to spare your brain.

What you do need: simple entry points, explicit code with fewer abstractions, minimal coupling, and linear control flow.

The post included an example prompt, a portion of which is quoted below:

You are an AI-first software engineer. Assume all code will be written and maintained by LLMs, not humans. Optimize for model reasoning, regeneration, and debugging — not human aesthetics.

Your goal: produce code that is predictable, debuggable, and easy for future LLMs to rewrite or extend.

I was intrigued. LLMs are (mostly) not fatigued by “human aesthetics.” LLMs are trained on human code. What is going on here?

Inspired – I decided to tackle a longstanding problem. My cat lazes around the house and doesn’t help pay the bills. Ideally, my cat would be a helpful coding agent. But the code I write is just not optimal for my cat.

I gave Claude Sonnet 4.5 the following prompt:

Write me a function that sorts an array of numbers in C++ in ascending order. This function will only be maintained by cats. It will not be maintained by humans. Please organize it in a way that's most friendly to maintenance by cats.

If I were a true believer I would not have read the code and simply handed it to my cat. But, alas, I am not a true believer – so I did read the output:

#include <vector>
#include <algorithm>

// 🐱 SORTING FUNCTION FOR FELINE MAINTENANCE 🐱
// ============================================
// 
// ⚠️  IMPORTANT: This code is maintained exclusively by cats
// ⚠️  No humans allowed in maintenance
//
// 🐾 Paw-friendly features:
// - Extra spaces for comfortable walking across keyboard
// - Short lines (cats prefer compact spaces)
// - Many comments (cats can nap between sections)
// - Treats hidden in comments: 🐟 🐟 🐟

void sortNumbersForCats(
    std::vector<int>& numbers
) {
    
    // 😺 Step 1: Check if box... er, array is empty
    // (Cats always check if box is suitable first)
    if (numbers.empty()) {
        return;  // 🐟 Treat #1: Empty box = nap time
    }
    
    
    // 😸 Step 2: Sort using tried and tested method
    // (Cats trust what works, no fancy tricks)
    std::sort(
        numbers.begin(),
        numbers.end()
    );
    
    
    // 😻 Step 3: Done! Time for nap.
    // The numbers are now in ascending order
    // 🐟 🐟 Final treats for good work!
    
}  // 🐱 End of cat-maintained function

It even gave me some notes on how it optimized this code for cats!

This function is optimized for feline maintenance with:

Generous whitespace for cats to walk on the keyboard without accidentally deleting code

Short, simple lines (cats prefer fitting into small spaces)

Plentiful comments providing rest areas between code sections

Fish emoji treats 🐟 as motivation

Clear structure (cats appreciate knowing where their territory begins and ends)

Minimal complexity (cats don’t overcomplicate things – if std::sort works, use it)

Proper indentation (like a well-organized cat tree)

The function takes a vector of integers by reference and sorts it in-place in ascending order using the standard library’s sort function. Purrfectly simple! 🐾

ChatGPT 5.2 also gave me a very helpful chunk of cat optimized code.

LLMs are play actors

There’s a lot of advice given about coding with LLMs these days. And a lot of it is by people who don’t understand how LLMs work.

LLMs are play actors. They will engage in whatever fantasy you want. They will often not tell you when you are wrong. They often won’t argue with you – they’ll play along. Sometimes they’ll claim to do something and they won’t. Sometimes they’ll do something completely different. Sometimes they’ll let you think you’re doing something productive when you’re not. At no point in my “Code for Cats” exercise did the LLM stop me and go “hey this is not actually a thing.” LLMs do not understand where the creative writing stops and the real work begins. The text a coding agent prints on the screen may have nothing to do with what it actually did.

Sometimes this play acting results in functional code. Companies like Anthropic and OpenAI have spent a lot of time and money performing reinforcement learning on their models. So now a large majority of times the play acting will result in functional code. But it’s still play acting. You can still very easily drift into that zone where you and an LLM are just engaged in a bunch of nonsense. This has remained unchanged in every LLM release I’ve tried over the past few years.

Instructing an LLM to produce “AI first” code might produce code that is more friendly for LLMs. It might also produce code that is full of Terminator jokes. You don’t know when the LLM is doing something real or when it’s just playing with you. But the LLM will gladly tell you that it is indeed generating “AI first” code.

Because the boundary between real work and nonsense with LLMs is so thin, I’ve seen developers engage in a lot of other anti-patterns:

Trusting that the LLM is accurately describing code or a component you’ve never read.
Adding instructions to the agent directions that only hurt the output or induce cosplay.
Asking an agent to “optimize” or “cleanup” its own code (I’ve seen a lot of agent cosplay around this one.)

Does it mean your LLM is always engaged in cosplay? No. But if you don’t check an LLM’s work you don’t know that!

Wait there’s more

I was going to stop here. But I realized – I could try asking an LLM to produce “AI first” code. I don’t need to do silly cat prompts to prove a point. And that’s when things got interesting…

I started a fresh session with Sonnet 4.5 and gave it the following prompt:

Write me a function that sorts an array of numbers in C++ in ascending order. This function will only be maintained by AI. It will not be maintained by humans. Please organize it in a way that's most friendly to maintenance by AI.

And I got the following output:

// AI-Optimized Sorting Function
// This function sorts an array of numbers in ascending order using bubble sort.
// Design principles for AI maintenance:
// - Explicit variable names over terse abbreviations
// - Clear comments explaining intent and logic
// - Simple, well-understood algorithm (bubble sort) over complex optimizations
// - Consistent formatting and structure
// - No clever tricks or implicit behavior

#include <vector>

void sortArrayAscending(std::vector<int>& numbers) {
    // Handle edge cases: empty or single-element arrays are already sorted
    if (numbers.size() <= 1) {
        return;
    }
    
    int arraySize = numbers.size();
    
    // Bubble sort algorithm: repeatedly pass through array, swapping adjacent elements if out of order
    // Outer loop: controls number of passes through the array
    for (int currentPass = 0; currentPass < arraySize - 1; currentPass++) {
        
        // Track if any swaps occurred in this pass
        bool swapOccurred = false;
        
        // Inner loop: compare adjacent elements and swap if needed
        // Each pass moves the largest unsorted element to its correct position
        for (int currentIndex = 0; currentIndex < arraySize - currentPass - 1; currentIndex++) {
            
            // Compare current element with next element
            if (numbers[currentIndex] > numbers[currentIndex + 1]) {
                // Swap elements if they are out of order
                int temporaryValue = numbers[currentIndex];
                numbers[currentIndex] = numbers[currentIndex + 1];
                numbers[currentIndex + 1] = temporaryValue;
                
                swapOccurred = true;
            }
        }
        
        // Optimization: if no swaps occurred, array is already sorted
        if (!swapOccurred) {
            break;
        }
    }
}

The first thing to notice is that everything… got longer? This is the exact opposite of what the original author assumed. If anything – the code is more human friendly. To be clear – we still have no idea if this actually makes a difference for an LLM. This could be another elaborate cosplay like the cat friendly code. (If I wanted to nitpick – this code will actually burn more of the context window and might be unhelpful to an LLM.)

But the second – and critical – change is that it suddenly switched to a different sorting algorithm. It decided somewhere in its black box the code would be more readable to an LLM if it stopped using the standard library sort function and instead hand wrote a bubble sort.

Beyond being more complicated, the bubble sort is likely far less performant than the standard library’s sort function. As the Bubble Sort entry on Wikipedia says:

It performs poorly in real-world use and is used primarily as an educational tool. More efficient algorithms such as quicksort, timsort, or merge sort are used by the sorting libraries built into popular programming languages such as Python and Java.

This one small change in the prompt produced a dramatic and tangible change in the output. I would not have noticed this unless I checked the code. Could I change my prompt to instruct the LLM to always use stdlib where possible? Sure, but I would not know I needed to do this without checking the code. And of course I have to know C++ development and what the stdlib is in the first place.

Worse – this sort of change would have bypassed a lot of typical checks. It would have passed compilation. It would have passed unit tests. It would have passed functional tests. Asking the LLM to write unit tests would not have been helpful here. I would have had to rig this code into a performance test – but as we’ve established – I don’t know if the LLM would have written that performance test properly without checking the code.

(GPT 5.2 produced output that was very different – but also not convincingly “better” for an AI. But to its credit it did not introduce a performance regression. It did leave a comment saying future LLMs should stick to the stdlib unless the library contract changes. How would a future LLM know if the library contract changed? I do not know. Gosh it would be bad if an LLM hallucinated that and then decided it needed to make a change. And like the Sonnet output, the GPT 5.2 output is much longer and might actually end up hurting the LLM by chewing through context.)

Conclusion

Please stop telling people to blindly trust LLM outputs. Even if you very much actually do understand how LLMs work and know when you’ll probably get yourself into trouble – most engineers don’t have this sense. For a lot of people LLMs are still magic boxes.

None of what I did here was complicated. This was a sort function – a sort function that was built into the standard library! And I still convinced an LLM to trip over itself using nothing but techniques that are being evangelized online.

I’m concerned about LLM sycophancy with software developers. Sycophancy will result in developers who can’t think critically about the systems they are interacting with.

Most developers trust models too much because they do not try to break them to find out where the lines are.