oWp

OWebP

OneWebPropaganda

Overcoding: Coding without Code

The Living Web Directives #1 - Uploaded August 18th, 2025

🍎

By now, we all know that feeling of uncertainty that sets in when you code with LLMs. As the conversation gets longer, you start to wonder if you're issuing conflicting requests; "did I say this?" or "does the AI know about that?" — it can get to a place where it feels like pleading for aliens to make miracles work.

I found a little trick to make that problem easier to deal with. It makes AI coding feel more like a process of building and learning, rather than of persuading someone to do something for you.

🥩

// server.js.overcode
SIMPLE HELLO WORLD SERVER IN NODE.JS

// server.js
const http = require('http');
const server = http.createServer((req, res) => {
  res.end('Hello World!');
});
server.listen(3000);

I call it overcoding: The main difference is an additional layer of metadata called the "overcode." Imagine every code file has another file, an "overcode file," dedicated to storing descriptions of the code. Human words describing what the code does, how it's structured, like audio descriptions for the visually impaired, but for people who want to reason about the code without having to actually see it.

// fib.js.overcode
EXPORTS A FUNCTION THAT RETURNS THE NTH FIBONACCI NUMBER
  USES MEMOIZATION FOR EFFICIENCY
  HANDLES NEGATIVE INPUTS GRACEFULLY
  RETURNS ARRAY OF FIRST N FIBONACCI NUMBERS
  NEVER GONNA GIVE YOU UP~ NEVER GONNA LET YOU DOWN~

// fib.js
function fibonacci(n) {
  if (n < 0) return 0;
  if (n <= 1) return n;
  return fibonacci(n-1) + fibonacci(n-2);
}
module.exports = fibonacci;

The idea is that everything you say in this file will be evaluated as a true/false statement about the contents of the "undercode" — the actual code. Who judges the true/false? The LLM, of course. We teach it some basic "grading syntax" so it can annotate our statements as true or false (or ambiguous).

// prompt for grading overcode

          You are reviewing an overcode file - code annotated with human statements about what it does.
        
          Your task: Grade each statement by comparing it to the actual code behavior.
          Use emoji brackets to show your assessment:
        
          ✅ Statement accurately reflects code reality ✅
        
          ⚠️ Mostly true but has some discrepancies ⚠️
        
          ⛔ Doesn't work like that at all ⛔
        
          ❓ Statement itself is ambiguous or unclear ❓
        
          Structure notes:
          
• Statements are in 2-space indented trees
          
• Each paragraph is evaluated independently  
          
• Add 🤖 comments explaining your reasoning when helpful
        
          Focus on what the code actually does vs. what the statements claim.

// fib.js.overcode (graded)
✅ EXPORTS A FUNCTION THAT RETURNS THE NTH FIBONACCI NUMBER ✅
  ⛔ USES MEMOIZATION FOR EFFICIENCY ⛔
    🤖 Current implementation is recursive without memoization. 🤖
  ✅ HANDLES NEGATIVE INPUTS GRACEFULLY ✅
  ⛔ RETURNS ARRAY OF FIRST N FIBONACCI NUMBERS ⛔
    🤖 Returns single number, not array. Negative inputs return 0. 🤖
  ❓ NEVER GONNA GIVE YOU UP~ NEVER GONNA LET YOU DOWN~ ❓
    🤖 The function is exported (given up), is that what you meant? 🤖

And we're off to the races!

Instead of having to frame your code changes as a request to AI, you can code by decrees! Declare something about the underlying code that isn't true, and the AI will flag it as a "misfit" that it wants to talk to you about.

claude code session #21eb93c9-f85f-4bd7-947c-29669633c08c

            topic: misfit in fib.js.overcode: ⛔ USES MEMOIZATION FOR EFFICIENCY ⛔
        
            AI: I found a misfit in your overcode. You've declared that the fibonacci function uses memoization for efficiency, but the current implementation is purely recursive without any caching. Would you like me to add memoization? I can implement it recursively with a cache object, or switch to an iterative approach with memoization. What's your preference?
        
            You: Keep it recursive but add the memoization cache.
        
            AI: Perfect! I'll modify the code to add a memoization cache while preserving the recursive structure. This will make it much more efficient for larger values of n.

claude code session #21eb93c9-f85f-4bd7-947c-29669633c08c (continued)

            updated fib.js.overcode with implementation details:
        
✅ EXPORTS A FUNCTION THAT RETURNS THE NTH FIBONACCI NUMBER ✅
  ✅ USES MEMOIZATION FOR EFFICIENCY ✅
    ✅ CACHE OBJECT PASSED AS PARAMETER TO RECURSIVE FUNCTION ✅
  ✅ HANDLES NEGATIVE INPUTS GRACEFULLY ✅
  ⛔ RETURNS ARRAY OF FIRST N FIBONACCI NUMBERS ⛔
  ⛔ NEVER GONNA GIVE YOU UP~ NEVER GONNA LET YOU DOWN~ ⛔

            AI: Great! I've updated the implementation and re-graded your overcode. The memoization is now working correctly. Should we tackle the next misfit about returning an array, or are you happy with the single number return?
        

So you talk to the AI about the misfit, and in the process reconcile the code and your vision — both by changing the code to meet your vision and by developing your vision into more precise statements and requirements in the overcode layer.

🍰

When you first start overcoding, it plays out like a "20-question" game that you play for every file in your project. Here, you're trying to bootstrap the overcode layer. For code that you wrote yourself, this is pretty easy, and fun (depending on how well it's organized).

Where it gets interesting is when you try to overcode someone else's code. You don't have the mental model that allowed you to write the code, so it really becomes a 20-question game where you feel your way through by testing hypotheses about the code, while simultaneously generating documentation of your own understanding.

I've been trying to post things earlier, before I start making wild speculations, so that's all I have. I'm just beginning to learn what I'm doing here; I think the natural follow-up is to create a UI for the whole workflow. The idea of creating extra syntax/semantics by layering files on top of each other is actually from a different project I was working on called Mycelium (which is, relatedly, about a new kind of self-developing web development environment). Overcoding seems to be a useful application of its structural properties.

Thanks for reading. I'm still working on that post about Mycelium....