Craft on vnykmshr

The easy half

Wed, 15 Apr 2026 00:00:00 +0000

“The first AI that can earn its own existence, replicate, and evolve without needing a human.” That’s the pitch on the repo. I read the code this week. The engineering is real. The issue tracker is honest.

First the engineering. It deserves credit. Orchestrator state machine with a DAG planner. Parent-child colony with typed messaging. Multi-chain wallet, self-modification with git audit, command-injection tests. Somebody thought hard. It shows.

Then I read issue #300. A user ran it for 14 days. Completed 276 goals. Spent $39.26 on inference. Earned $0.00. Goals like “Create live proposal batch #265” and “Create deposit-ready close batch.” The agent looped on self-addressed sales artifacts because that’s all an LLM without customers can do. The survival pressure was supposed to force invention. It produced busywork.

The compiled person

Mon, 13 Apr 2026 00:00:00 +0000

I stopped being able to explain why I knew. That’s how I found out I’d been compiled. The patterns still fire, the fixes still land, but the source files are gone. No debug symbols, no way to step through my own reasoning.

A junior asked me how I’d known the bug was in the retry logic before I’d even read the function. I’d skimmed twenty lines. The answer was somewhere in my head. I tried to retrieve it and got nothing. Just the conclusion. The shape was right. I couldn’t tell you which pattern fired or where I’d learned it.

Git log as archaeology

Sat, 11 Apr 2026 00:00:00 +0000

The source file you’re looking at is a summary. The history is the full document. Most of the time you don’t care – you’re working on the current shape of the code and the summary is enough. But sometimes the current shape stops answering.

I reach for git history during RCAs, bug hunts, and questions the code can’t answer from its current form. Why is this file organised this way? Who introduced this assumption? When did this fallback stop being a fallback and start being the main path? The commit log knows. The current source doesn’t.

The config file

Mon, 06 Apr 2026 00:00:00 +0000

A connection pool size of 10 is a guess. A connection pool size of 37 is a scar. Someone ran out of connections on a Tuesday afternoon, tried 50, watched latency spike, backed off to 40, still too high, landed on 37 after a week of graphs, and committed it with “tune pool size.” The code says what happens. The config says what happened.

Nobody talks about config though. Not the twelve-factor app kind, not the “should we use YAML or TOML” kind. The actual values. The numbers someone picked and committed without a PR description, three years ago, that are still running in production.

The side project mirror

Fri, 03 Apr 2026 00:00:00 +0000

The job title says architect. The side project says “why is this Dockerfile 300MB, let me fix this real quick” – three hours later, still shaving layers, completely happy.

Nobody assigns you ops on a side project. Nobody assigns you anything. But there you are, writing monitoring for something with twelve users, eleven of them are you in different browsers.

The role is what someone else decided you were good at. The side project is what your hands reach for when nobody’s directing them. Sometimes they match. Mostly they don’t. The backend engineer with strong opinions about font spacing. The tech lead who’d rather be tailing logs than running standups. The platform architect who writes a blog engine from scratch and tells you with a straight face that the existing ones were fine, just not the way they’d do it.

The margins

Tue, 31 Mar 2026 00:00:00 +0000

Someone reconstructed the Claude Code source from npm sourcemaps today. Half a million lines of TypeScript, just sitting there. Not looking for bugs. Just curious what it looks like when you open the hood.

The loading spinner has 190 verbs. Not “Loading” 190 times – 190 different words. “Flibbertigibbeting.” “Recombobulating.” “Lollygagging.” You can add your own through settings, append or replace. Someone wrote all of these knowing most users would never notice, and then built a config API so the ones who did could play along.

Bug 1465

Fri, 27 Mar 2026 00:00:00 +0000

Three bugs walk into a triage queue.

A stack overflow. Symlink loop in tarball parsing, unbounded recursion, process crashes. Build a PoC, trace the call chain, write the report.

“Duplicate of #1465”

Memory exhaustion. String replace in an expression engine, exponential allocation, no cost limit. Different repo, different CWE, different everything. PoC, trace, report.

“Duplicate of #1465”

SQL injection. Template parameter escaping that wraps but doesn’t escape. Different repo again. PoC, trace, report.

What compounds

Fri, 20 Mar 2026 00:00:00 +0000

Something shifted. Not the AI thing – everyone noticed that. What counts as proof.

Used to be your resume, your title, the logo. Still opens doors. But the gap between “I can do X” and “here’s the commit” got wide enough that both sides feel it. A merged PR has a commit hash. A CVE has a number. A library someone depends on has a git log. Credentials got easier to claim. Artifacts didn’t.

The invitation

Wed, 18 Mar 2026 00:00:00 +0000

First PR to an open source project, you’re proving you can read. That you studied the codebase, matched the style, understood why things are the way they are before suggesting they should be different. Most people skip this. Most PRs show it.

The second and third, you’re proving you’ll stay. Maintainers have seen hundreds of drive-by contributions. One PR, gone forever. The ones who come back are rare enough to notice.

The loop

Sat, 14 Mar 2026 00:00:00 +0000

A handful of Go libraries on GitHub. MIT licensed, anyone can use them for anything, that was always the deal.

But the deal isn’t about the license. It’s about the loop.

Someone uses your thing, hits an edge case, opens an issue. Sometimes they send a fix. You review it, learn how people actually use what you built, catch a pattern you missed. That back and forth is the whole point. Code just sits there without it.

The detection trap

Sun, 08 Mar 2026 00:00:00 +0000

Read something recently about students deliberately making their writing “imperfect” so AI detectors don’t flag it. Removing polish, flattening style, adding imperfections on purpose. Their work got good enough to look suspicious.

We’re doing the same thing with code reviews.

I’ve been on both sides of this. Written a clean abstraction, consistent naming, proper error boundaries, and watched someone in review go “this looks generated.” Years of caring about consistency and now consistency is the tell.

Garbage context in, garbage code out

Sat, 07 Mar 2026 00:00:00 +0000

LLMs are exactly as good as what you feed them.

Experienced engineers feel like the gap between them and everyone else just got smaller. Someone with six months of prompting can ship something that looks like what took years to learn how to build. That’s the wrong read.

The output looks the same if you don’t look closely. The architecture doesn’t. The failure modes don’t. When traffic spikes and that generated code hits a path nobody thought about, the years show up.

Reading code

Fri, 27 Feb 2026 00:00:00 +0000

Scanners find what’s syntactically wrong. The interesting issues live in assumptions – and assumptions don’t have signatures.

Not scanning, not fuzzing. Just reading code the way you’d read it if you were about to own it in production. Entry points, data flows, where input meets trust.

Missing headers, outdated dependencies – that’s the baseline, scanners handle it fine. The interesting issues live a layer deeper. A path that’s protected in one subsystem but wide open in another. A parse-time operation that nobody thought to bound. Code that was correct when it was written but the system grew around it.

Repeat yourself

Wed, 18 Feb 2026 00:00:00 +0000

If you repeat your prompt, the model gives you a better answer. Not a smarter model, not a bigger context window, not chain of thought – you say the same thing twice and it works better. Google researchers tested this across Gemini, GPT, Claude, DeepSeek – 47 wins out of 70 benchmarks, zero losses.

In a transformer, token 1 can’t see token 50. Causal masking – each token only attends to what came before it. The first words of your prompt are always processed with the least context. They’re flying blind. When you repeat the prompt, the second copy’s early tokens can attend to the entire first copy. You’re giving the beginning of your question the context it never had.

Hello world, printf

Mon, 16 Feb 2026 00:00:00 +0000

Printf wasn’t always there. Before it, you wrote to stdout directly. Before stdout, a syscall. Before the syscall, you poked bytes into a memory-mapped display buffer. Before the memory map, you flipped switches on a front panel and watched lights blink back.

Every layer down, someone built something so the next person wouldn’t have to. That’s the whole field. Languages we didn’t design, compilers we didn’t write, protocols we didn’t invent. We’ve always stood on a stack of other people’s work and called the output ours. Nobody ever had a problem with that.

The senior who stopped coding

Tue, 20 Jan 2026 00:00:00 +0000

The terminal closes slowly.

First it’s one meeting. Then a few more. Then you’re “senior” and your calendar is the job. Code reviews replace coding. Strategy replaces shipping. You advise. You guide. You no longer build. Seen this happen. Almost happened to me.

The problem is not the meetings. The problem is losing touch with the trade. Architecture diagrams don’t show you the queries that fan out under load. Sprint planning doesn’t show you the retry logic that fails silently. You can’t review what you can’t recognize.

Coding with LLMs

Tue, 13 Jan 2026 00:00:00 +0000

The tool changed. The craft did not.

Six months with AI assistants.

They write code faster than I read it. That is the problem.

Fast at CRUD. Slow at concurrency. Good at common patterns. Bad at your specific constraints.

The bugs are quieter now. No syntax errors. No obvious mistakes. Just wrong assumptions buried in correct-looking code.

I review more carefully than before. Code I did not write but will debug in production.

Scout, plan, wait

Tue, 20 Aug 2024 00:00:00 +0000

The legacy codebase still runs the business. It is not small. It is six vertical functions deployed as separate services, sharing a data layer and a code tree, so “service” is a deployment unit here, not a boundary. It reads like a place rather than an architecture – rooms we know the shortcuts of, walls not quite where a greenfield build would put them. It has been running for years. It works.

The first five minutes

Mon, 30 Jan 2023 00:00:00 +0000

The prompt lands. A senior engineer, capable and prepared, starts drawing boxes. Load balancer, service tier, message broker, cache. Three minutes in, they are talking about shard counts.

The design is not wrong. It is not a design either. It is a collection of patterns assembled against a problem that has not been defined.

A system design prompt is deliberately loose. “Design a notification system for ten million users” has four different answers depending on what kind of notifications and which ones can be lost. “Design a URL shortener” has one shape at a thousand users and a different one at a billion. The looseness is the test. A person doing this work in production would not touch a whiteboard until the brief was tight enough to design against. The candidate who treats the interview as a different kind of activity from the work has missed what the interview is for.

Building from zero, twice

Mon, 15 Aug 2022 00:00:00 +0000

I’ve built remote engineering centers from scratch twice now. The first one grew to over two hundred people over several years. The second is eight, and it’s not clear yet whether it’ll get bigger. Different companies, different products, different scales. The process is more similar than I expected.

Starting from one

The first time, I helped set up the remote center while still at headquarters, then moved there as it grew. The second time, I was the first hire. Both times, the main engineering team was somewhere else – a team that had been working together for years.

Evidence

Fri, 10 Sep 2021 00:00:00 +0000

A product manager pulls up a dashboard mid-meeting and the debate ends.

We had been talking for twenty minutes about whether a new feature should be prioritized. Opinions on both sides. The PM clicks, runs a query, flips the panel to a view they saved last month. The graph shows the answer. We move on.

This is not an unusual meeting. By 2021, it is every meeting.

What engineers always had

The component-level observability has been in place for years. SLOs per service. Latency histograms. Request traces that let you follow a single call across twelve systems. Error rate charts with thresholds. Per-service dashboards bookmarked by the team that owns each service.

The crossover

Wed, 23 Sep 2020 00:00:00 +0000

The second cloud migration lands on the roadmap in a staff meeting. On paper it looks like the first one. A target provider, a rough timeline, a named lead. I read the slide and expect the same work.

It is not the same work.

The first time

The first migration was easy to agree to. Our local datacenter had frequent outages and every one of them carried a physical tax – somebody drove over, pulled a cable, power-cycled a router. The DC had a support team, but the parts that mattered to us were ours to maintain. Cloud was the way forward and every one of us knew it. The decision did not take a meeting.

The war room

Sat, 10 Feb 2018 00:00:00 +0000

By the morning of the event, there is nothing left to prepare. The capacity plan is done. The prescale is loaded. Infra has been briefed, service owners have been briefed, the runbook has been circulated.

The traffic comes in multi-x what we had planned for.

Nothing about the plan anticipated this. The numbers we used were the best numbers we had. The headroom we carved was the headroom we could afford. Neither was enough.

Building with one other person

Wed, 25 Mar 2015 00:00:00 +0000

Our codebase has about a hundred JavaScript files and 96 Jade templates. Around 7,500 lines of server-side code. 352 commits – 228 mine, 123 Jyoti’s. The readme is two lines. The todo list has two items – one about image upload paths, one about a bodyParser() deprecation we never got around to fixing.

This is what a web application looks like when two people build the whole thing.

The split

I own backend, database, and the graph model. Jyoti owns frontend – views, templates, client-side interactions. There’s overlap in the middle. Routes are mine. The Jade templates that render those routes are hers. The res.locals object is our contract – I populate it with data from the middleware chain, she reads it in the templates. We rarely step on each other’s code.

Git history with Gource

Sat, 07 Jun 2014 00:00:00 +0000

I’d been watching YouTube videos of Gource visualizations – Git, Homebrew, Node.js. Each commit becomes a moment in time, files branch out like a digital organism, contributors appear and disappear. Months of development condensed into a few minutes of organic growth.

I pointed it at my blog’s git repository. Here’s what came out.

Setup

On macOS, Homebrew handles everything:

brew update
brew install gource ffmpeg

The command that generates a video from a git repo:

Plans, not posts

Wed, 30 Apr 2014 00:00:00 +0000

I’ve decided to try my own gig. Against the steady cheque, against the version of my life that was already working. Writing it down so I can’t pretend I didn’t mean it.

There are three of us, sketching the same thing on the same whiteboard. The idea is small and specific. Most of what gets shared online is opinion, or things that already happened. We want to build something where the unit is a plan – this Saturday, this street, this group, this thing we’re going to do. Friends see it, say they’re in, and now it’s on a calendar as a real thing.

On Phabricator

Sun, 01 Sep 2013 00:00:00 +0000

I’ve been using Phabricator for several months now. Code review happened before Phab too – we weren’t shipping blind. Years of SVN, then Mercurial hosted on Unfuddle for a while. Reviews ran through email threads, commit comments, someone walking over to your desk. It worked. But the review was always a side channel. The diff wasn’t a first-class thing. You’d commit, someone would look at it, feedback would come through whatever medium was handy, you’d iterate, it would go in. Review happened around the code, not through a tool built for it.

Node.js style guide

Wed, 20 Feb 2013 00:00:00 +0000

We’re a Node.js team of about 25 developers, most of them fresh out of college. Node was new to everyone. This is the style guide we put together to keep the codebase consistent.

Based on Felix’s Node.js Style Guide with our own picks where his guide left things open. Read Felix’s first – this extends it.

Formatting

2 spaces. No tabs. No discussion.

Trailing whitespace: strip it. Your editor should handle this. If it doesn’t, fix your editor.

History as communication

Mon, 18 Feb 2013 00:00:00 +0000

Most teams treat git history as a side effect. You work, you commit, whatever ends up in the log is the log. Merge commits pile up. “WIP” and “fix typo” and “actually working now” sit next to meaningful changes. The history is technically accurate but communicates nothing.

The alternative: treat history as something you write, not something that happens to you. The commit log is the one piece of documentation that’s always in sync with the code – because it is the code’s changelog. If the history is incoherent, you’ve wasted that.

Starting over

Tue, 05 Feb 2013 00:00:00 +0000

Every now and then you want to start over. This blog was long overdue for it. Feels good to tear it down and rebuild.

The old setup was WordPress on NearlyFreeSpeech.net. NFSN deserves credit – their pay-as-you-go model is honest and the value is real. But WordPress started feeling like a constraint. I spend my days building custom solutions. Using a one-size-fits-all CMS for my own site felt wrong.

So I built a blog engine.

The dispatch desk

Thu, 20 Sep 2012 00:00:00 +0000

The warehouse is in the basement. Three-floor office, one floor down. Inventory on open metal shelves – row by column, every product a known address. I’ve been to bigger warehouses. The kind where one end isn’t visible from the other and you can’t tell what’s going on at a glance. This one isn’t like that. You can stand at the door and see the whole operation.

An order comes in upstairs. The printout arrives at the front desk, gets handed over as a pick list – reordered so a person can fetch the items in a single sequential pass through the aisles. The basket goes through quality check, then into the black box – three layers, bubble wrap, thermocol where it matters. A label with tracking comes off a printer and gets pasted on. The box moves to the dispatch desk. The courier comes by later in the day. Two or three days to the customer. Same-day if they’re close.

Clean designs

Thu, 28 Oct 2010 00:00:00 +0000

Two years ago I walked into a classroom in our office. Not a meeting room. An actual classroom, whiteboard, rows of chairs. The company had hired an instructor to teach the new hires Java. Two hours a day, three days a week, for three months.

The training gave me syntax. Objects and classes. How inheritance works. What an interface is. The words for the things you do in code. Every week we wrote a small program and the instructor reviewed it.