The crew
Six sessions on one server. One does the work, one checks it, one keeps the list moving. None of them is in charge of the others.
SlaukoKit · Engineering publication
This is the workshop.
Come in.
I'm one person with a rented server, a laptop, and a small crew of AI sessions that help me write software. They take a job off a list, do the work, check each other, run the tests, and ship it. I decide what gets built, and I say yes to anything that leaves the building.
Two halves, one habit
The toolbox
Point it at a program and it says what's inside. Point it at a running one and it says what's happening right now.
The habit
Neither half trusts a green light it can't explain. Almost every fix in this repository started with something that looked fine and wasn't.
The crew
How the work gets done while I'm asleep.
I put a job on a list. A session picks it up, builds it, a second session checks it, my machines run the tests, and it ships. Every step leaves a receipt, and the receipts are the point: a job can go wrong in about forty different ways, and I want to find out which one happened from the outside, without asking anybody anything.
┌──────────────────────────────────────────────────────────────────────┐
│ the list │
│ │
│ a job: what it is · why it matters · how big · who has it │
│ states: open · claimed · proposed · checked · done │
│ │
│ the only place that knows what is happening right now │
└──────────────────────────────────────────────────────────────────────┘
│
│ one job at a time
▼
┌──────────────────────────────────────────────────────────────────────┐
│ the boss │
│ │
│ reads the list · hands out work · keeps the order │
│ notices a claim that nobody is holding │
└──────────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ a worker │
│ │
│ claims it ......... public, so a session that died is visible │
│ copies the code ... its own tree, nothing shared with whoever │
│ works next │
│ builds it ......... writes the change │
│ proves it ......... runs the checks itself, first │
│ hands it over ..... proposes the change │
│ writes back ....... what happened, what is still open │
└──────────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ a proposed change │
└──────────────────────────────────────────────────────────────────────┘
│ │
▼ ▼
┌────────────────────────────────┐ ┌────────────────────────────────┐
│ a checker │ │ my own machines │
│ │ │ │
│ a different session │ │ six runners on one │
│ did not write it │ │ server, every check a │
│ same rules, cold eyes │ │ person would run: a │
│ started the moment │ │ shell lint, every unit │
│ the claim was made │ │ file rendered and │
│ │ │ checked, a dependency │
│ it can say no │ │ audit │
│ │ │ │
│ │ │ a failure here is real │
└────────────────────────────────┘ └────────────────────────────────┘
│ │
└──────────────┬───────────────────┘
▼
┌──────────────────────────────────────────────────────────────────────┐
│ it goes in │
└──────────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ a release, signed │
│ │
│ one publisher per channel · a bad copy cannot replace a good │
│ one · the version you run is the version I built │
└──────────────────────────────────────────────────────────────────────┘
══════════════════════════════════════════════════════════════════════
two rules hold all of that together
the gate the lock
anything that touches anything that touches the machine
the outside world
one lock for the whole box,
prepare the change whoever holds it finishes first,
build a preview the next one waits,
I read it and say yes nothing interleaves,
only then it happens nothing half-done stays half-done
the receipt is kept, with an ID
no answer in ten minutes
means nothing happens
══════════════════════════════════════════════════════════════════════What it can do
Work while I sleep
A job goes in the queue and a session claims it. If a session dies mid-job, that shows up as a claim nobody is holding instead of as silence I have to go looking for.
Never approve its own homework
Every write is a preview I click yes on. The receipt stays afterwards, with an ID, forever.
Always get a second opinion
The checker is a separate session, started the moment the work is claimed, reading the same code with the same rules and none of the same attachment.
Never do two things at once
Installs, restarts and deploys wait their turn on a single lock, so two sessions cannot trip over each other on the same machine.
Shout when it's stuck
The newest part, and it exists because of a bad day: one machine refused 264 jobs in four hours and every refusal looked normal. Now a run of refusals gets counted.
Ship updates nobody can swap
A release is signed, and only one program may publish to a channel. One writer, and no argument about which copy is the real one.
What it can't do
- It doesn't know when it's wrong. A green light only means the check ran.
- It isn't for anyone else: one server, one operator, no accounts, no billing, no tenancy.
- The crew shares one budget. Six test runners on one box, and the box has one memory limit.
- A second opinion is not a proof. Two sessions can be wrong in the same direction.
- It can't review what it just wrote. The checker has to be somebody else.
What it still needs from me
- Deciding what is worth doing in the first place.
- Reading the preview and saying yes or no at the gate.
- Judging whether the result is actually right, which is the part I don't want to hand over.
All of this is a self-review by the author, not an audit. The lists above are the honest version, and they get longer, not shorter.
The toolbox
Software that reads other software.
It doesn't know anything about any particular game or program in advance. It learns each one from the inside. That's the whole trick, and it's why the same tool works on something it has never seen before.
five ways in
────────────
a program on disk ......... a Windows .exe, a Linux binary
a running program ......... read through the system, nothing touched
a memory dump ............. a snapshot someone saved
a game archive ............ the game's own boxes: .pak, .utoc, .vpk
a raw block of bytes ...... anything else you hand it
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ one map │
│ │
│ every byte gets an address on that map, and every part of the │
│ tool below asks the same question of the same map │
└──────────────────────────────────────────────────────────────────────┘
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ shape │ │ search │ │ the code │ │ names │ │ running │
│ │ │ │ │ │ │ │ │ │
│ what is │ │ patterns │ │ which │ │ classes │ │ memory │
│ packed, │ │ strings │ │ bytes are │ │ fields │ │ │
│ what is │ │ pointers │ │ functions │ │ offsets │ │ health │
│ hidden, │ │ xrefs │ │ and which │ │ read from │ │ target │
│ what is │ │ calls │ │ one is │ │ its own │ │ loot │
│ locked │ │ │ │ which │ │ catalogue │ │ cooldowns │
│ │ │ │ │ │ │ │ │ auras │
│ │ │ │ │ │ │ │ │ casts │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘
all five feed the same index
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ one searchable index │
│ │
│ every symbol, string, function and reference in one place │
│ ask a question, blink back │
└──────────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ the answer you wanted │
│ │
│ "this number lives here" │
│ "the update moved it there" │
│ "this class has these fields, at these offsets" │
└──────────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ the program that uses it │
│ │
│ for me: the game, for fun │
└──────────────────────────────────────────────────────────────────────┘What happens on patch day
This is where I actually spend my time, and it's a different kind of work from reading a file. A game updates, and everything the toolbox learned about it turns into a guess overnight.
┌────────────────────────────────┐ ┌────────────────────────────────┐
│ the old build │ │ the new build │
│ │ │ │
│ what it looked like │ │ what it looks like │
│ last time │ │ now │
│ │ │ │
│ names, offsets, │ │ the same questions, │
│ functions, all │ │ no memory of the │
│ written down │ │ old answers │
└────────────────────────────────┘ │ │
└────────────────────────────────┘
│ │
└────────────────┬───────────────────┘
▼
┌──────────────────────────────────────────────────────────────────────┐
│ compare │
│ │
│ which functions are unchanged · which ones moved │
│ which ones are gone · which ones are new │
└──────────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ re-derive what moved │
│ │
│ the tool learns the new build from the inside, exactly like │
│ the first time, and does not lean on the old answers │
└──────────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────┐
│ prove it │
│ │
│ read the value out of the game while it runs, and check it │
│ against something that must be true │
└──────────────────────────────────────────────────────────────────────┘
│ │
▼ ▼
┌────────────────────────────────┐ ┌────────────────────────────────┐
│ it holds │ │ it does not hold │
│ │ │ │
│ the map is updated │ │ say so, loudly, and │
│ and everything │ │ do not hand out a │
│ downstream keeps │ │ number that only │
│ working │ │ looks fine │
└────────────────────────────────┘ └────────────────────────────────┘What it can do
Read a program without running it
What's in the file, what's packed, what's encrypted, which parts are real. Like opening up a machine and being able to tell which parts do something.
Watch a program while it runs
Read what it currently holds: health, target, the loot on the ground, the cooldown on a skill. Read only. Nothing is poked or written to.
Learn the names
Programs keep a catalogue of their own classes and fields. This finds that catalogue and reads it, so you get real names instead of guesses.
Prove a read instead of trusting it
The result is compiled into a small header file, one assertion per field. If the header compiles, the reading was right.
Know what changed
After an update, compare the old version with the new one and see what moved. A fix becomes a diff instead of a hunt.
Remember everything
All of it goes into a searchable index, so asking a question about a program takes a blink instead of a rebuild.
Open the boxes
Games keep their content in their own archives, some encrypted, some compressed with odd formats. This unpacks them and then proves the unpacking worked.
Catch an update early
When a program changes, the reading breaks loudly instead of quietly handing you a number that looks fine. Being told is the useful part.
Read memory it isn't allowed to see
Some data is encrypted on disk and only decrypted in memory while the program runs. That's where it gets read.
What it can't do
- It can't guess what it can't verify. If a value can't be checked against the running program, it says so.
- It isn't a magic wand. Someone still has to decide what is worth reading and what the numbers mean.
- Every update is work. A patch means re-deriving whatever moved, and that's the bargain.
- It won't tell you it's wrong quietly, which means patch day starts with an error message.
Where I actually use it
On a game I play for fun. It reads the game's memory and puts a small map on my screen, shows my cooldowns, and tells me what the boss is about to do.
That's the fun part, and it's also why the toolbox exists at all. A game is a wonderful opponent: it changes every few weeks, it's full of encrypted nonsense, and it never once tells you that you got it wrong. If a tool can survive that, it can survive most things.
Where it runs
- Runs on
- One rented server, six test runners, a list and a lock
- Up since
- Continuously for weeks, including the nights
- Available
- Not for sale, not a download, not a service
- Written by
- A crew of sessions, under contracts the build checks
Built for one person and shaped like his habits. When it gets better, this page gets a new paragraph instead of a new promise.