About
Six years as a COO taught me that how a company actually runs lives in people's heads and…
Services
Articles by Antony
-
The Dad, the Library, and the End of Software Engineering as We Knew It
The Dad, the Library, and the End of Software Engineering as We Knew It
I met a software engineer in the library today. He was supervising his kids.
4 Comments
Activity
2K followers
-
Antony Evans posted thisHere's why 'AI wrote it, so it's not real' is the wrong test for whether a post is honest. The AI writes better sentences than I do. What I haven't handed over is the idea. This post ran through the exact pipeline it's describing, hook to publish. A spawned AI drafted the hook options, wrote this draft, then ran a humanizing pass to strip the tells. I read the result, cut what wasn't mine, and only then does it go out. The same run also built the X-thread version of this post. None of that is hidden. It's how these posts get made now. The test people reach for is whether a human typed every word. That's the wrong test. My transaction with you was always the idea, not the prose. Ghostwriters and PR shops proved this years before any model existed: a beautifully written sentence wrapped around a hollow idea already wasted your time. AI just makes the wrapping cheaper to produce, which is exactly why authorship of keystrokes stopped being the right question. Provenance of the idea is. That standard comes with one condition. It holds only if the thinking underneath is mine first. The day I start asking the model what to believe, instead of how to say what I already believe, the post stops being mine. Do the thinking yourself. Let the tool carry the sentence. Where would you push back: the sentence, or the thinking behind it?
-
Antony Evans posted thisI asked my AI to audit its own product's code for what was making development slow and expensive. I expected it to blame the code. It blamed me. The code came back healthy. Small files, clean layers, a CI gate that runs the whole suite in two and a half minutes. The drag was everywhere else, and all of it was mine. I had a rule: run the full test suite before you call anything done. Eight minutes, cold, every time. A normal build loop runs that three or four times, so half an hour of a session was just watching a progress bar fill. Meanwhile the CI that actually decides whether code merges does the same job in two and a half minutes. I had the machine waiting on a slower copy of a check the fast one already owned. Then there was a script that wipes every cache before it runs. I wrote it to kill a real staleness bug in one corner of the stack. It was running that same purge on a corner where the bug cannot happen, forcing a cold rebuild from scratch every single time. And the build pipeline was writing the same code twice. Once as a plan. Then again for real. None of this was broken. Every one was a guardrail I put up on purpose, for a reason that was true the day I wrote it. They just kept charging me long after the reason expired. The model was never the expensive part. The ceremony I built around it was, because I did not trust it yet, and I never went back to tear it down once I did. So I am auditing my own process the way I audit the code now. Every safety rule I own gets one question: is this still protecting me, or is it charging rent on a fear I already outgrew? When you added a check "just to be safe," how would you actually know the day it stopped earning its keep?
-
Antony Evans posted thisThis week I gave my company mind away as something anyone can actually install, and the hardest part was making it boring. For months the mind lived where only I could see it. Today it became a real release with a version number, a one-line install, and instructions to plug in your own AI subscription instead of mine. You run it on your box. Your knowledge stays on your side. I never hold the keys. That last part is the whole point, and it's why the release took a full day instead of an hour. Owning your own mind only means something if I'm not standing in the middle of it. So the product had to stand itself up on a machine I don't own, from nothing, and answer a real question before I'd call it shipped. The gate nearly stopped me. My release check came back 57 green out of 58. One red row. I could have shrugged at a single failure and shipped anyway. Instead I spent an hour proving what the red actually was, and it turned out to be a bug in my test, not the product. The check was a JSON grep looking for a token with a space in it. The product writes that token without the space. The test was wrong. The product was right. I fixed the test and let the gate pass honestly. Then, across the whole run, I stood up fresh cloud boxes one at a time, building each from nothing and tearing it down before the next one existed. Never two alive together. None left running. None left holding anything. I'll be honest about one thing I didn't finish. I proved a clean install works, not yet a clean upgrade from the last version. So I shipped the install and held the upgrade proof for its own gate rather than claim both. Sovereignty is a hundred boring decisions about who holds what: whose subscription pays for the tokens, whose disk holds the data, who could see any of it if I disappeared. It only counts when the architecture makes those true, even when that costs me a day I didn't plan for. What's the one system you rely on where, if you're honest, someone else still holds the keys?
-
Antony Evans posted thisI spent today deciding what my own product is allowed to reach. The answer I kept landing on was: nothing of yours. I'm building a way to run a company mind for people who don't want to run the servers themselves. The obvious way to do that is the way most software does it: I host it, I hold the keys, I can look inside whenever I want. Convenient. Also exactly what my whole pitch argues against. So I inverted it. The box holding your knowledge lives on your side. It reaches out to me for the things a service has to handle: updates, health checks, billing. My side never reaches in. There's no door from my control panel into your data, because I never built one. If a customer walked away tomorrow, there's nothing of theirs on my side to hand back. There was never anything there to begin with. It's less convenient for me. I can't peek in to debug. I can't quietly mine usage data. I can't become the one place your operating knowledge secretly lives. That last one is the whole reason I'm doing this. Sovereignty over your mind only means something if the architecture enforces it, especially when enforcement costs the vendor something. A slogan on a landing page never will. If a vendor tells you that you own your data, but their system can reach into yours whenever it wants, do you actually own it?
-
Antony Evans posted thisI had someone from outside look at code my AI wrote this week. Not the output, the actual work. Every file, every test, every corner where a tired human would have cut one. The verdict was better than I expected. The discipline held. No file over the length limit, a header on every one so an agent knows where it sits, not a single "fix this later" note left rotting in the tree, and more test code than feature code. Hundreds of tests, all green. The machine wrote it and kept its own house clean. Then came the part I keep turning over. The same review found six holes. A feature had shipped while the document meant to approve it sat in a folder nobody had committed. The map that tells every future agent how the system is laid out had drifted a full generation out of date within a day of a big merge, still pointing at files that no longer existed. Every one of those six holes came from the same place. The rule was a sentence. "Keep the map current." "Don't ship without the approval." Written down, in a file, in plain English. And a written rule is a suggestion the moment someone is moving fast. The code discipline held because a machine checked it. The process discipline slipped because good intentions checked it. So I didn't fix the six holes. Patching them would have lasted until the next busy afternoon. I spent the day turning each rule into a gate. Instead of "please keep the map current," the build now fails when the map disagrees with the code. Instead of "remember to commit the approval," you cannot merge without it. Then I pushed those gates down into the shared kit, so every repo I build from here inherits them instead of learning the same lesson twice. What I've landed on is almost embarrassingly simple. If a rule matters, it can't live in prose. A rule you have to remember is a rule you will eventually skip, and the day you skip it is always the day it mattered. The only rules that survive a real deadline are the ones a machine enforces whether you like it or not. I trust the parts of my system that can't be talked out of doing their job. Everything else is just a note to myself. What's one rule in how you work that only holds because everyone's being careful, and would break the first busy week if nothing was checking?
-
Antony Evans posted thisFor weeks my company mind could read itself but not change itself. Today I let it write back, and the hard part wasn't the writing. It was deciding what it's allowed to change without me. The read layer came first. My AI navigates the mind the way a person would, moving through structure instead of searching by similarity. That was the easy half. A mind you can only read is half a mind. Real operating knowledge doesn't sit still: a decision gets made, a number goes stale, the morning brief learns something the system should keep. So the AI needs to write. Left ungoverned, that's a liability: one bad patch away from breaking something that mattered. Every write lands in a zone, and every zone carries its own posture. The AI merges some zones on its own. Others need a second model to check the patch before it lands. A few are off limits to anything but me. Nothing changes silently. I get a receipt for every write, and I can veto it. Whatever reviews a change is never the model that wrote it. That separation is the whole design. It's easy to get excited about an AI that keeps your knowledge current on its own. The discipline is refusing to let it do that ungoverned. Owning your mind means deciding how it's allowed to change. Reading it is the easy part. If you let an AI edit your company's knowledge, where's the line it should never cross without you?
-
Antony Evans shared thisThese 5 steps are literally the strategy to build with ai: https://lnkd.in/en7HsRcz
-
Antony Evans posted thisTonight my own system refused to do what I told it to. I was deep in a build, late and moving fast. The feature I was working on decides which AI model handles which job, and I gave it a simple rule: send the background work to the cheaper model. It was in the task. It was in the brief. Go. It didn't go. It stopped and told me the instruction contradicted a decision I'd made a week earlier. Back then I'd chosen the opposite. Never quietly downgrade someone's work to save a few cents, run it on the setup they actually paid for. I wrote that down, forgot I'd written it, and tonight I typed the old version straight back into the build without noticing. The part that got me is that the system noticed. It checked what I was telling it against the record of what I'd already committed to, saw the two disagreed, and held. Then it built the version I'd actually decided on, and quietly flagged the one I'd typed in a hurry. A year ago I'd have called that a bug. The machine ignored a direct order. Now I think it's the most valuable thing I've built. The whole point of an operating model is that your decisions outlive the mood you were in when you fired off the next instruction. If the record can't overrule you when you're wrong, it isn't governance. It's an expensive notepad. I spend a lot of my week telling clients to verify their verifiers. This was the first night mine verified me. When your past self and your present self disagree, which one should your system trust?
-
Antony Evans shared thisI wrote the falsification test that could have killed my own thesis, then ran it. Vector search lost by more than I expected. The mind I sell rests on one claim. An AI that reads structure the way a person would beats an AI that searches by similarity. If that's false, the product doesn't work. I didn't want to learn that from a client, so I wrote down the result that would kill it, then ran it. Same 40 questions, same corpus of about 1,470 files, three contenders. One reads a summary and an index map, follows the folder logic, then opens files. One is vector embeddings, pure similarity. One bolts keyword search onto the embeddings. Judged on one thing: did it find the right file? Structure got the right file first 75% of the time. Embeddings alone: 43%. Keyword-plus-embeddings: 38%, worse than embeddings by itself. Top five on 39 of 40 questions. It won plain factual lookups, and it won hardest on the questions about why a document exists, rather than what it says. Mid-tier model too. Structure did the work, not the horsepower. My instinct was that dumping everything into a vector database is the safe first move. This test says the opposite. A well-kept structure (summaries, an index, folders that mean something) encodes judgment a similarity score can't see. Structure is the moat. One run, not ten, and it assumes a well organised corpus. Feed both methods a messier pile and embeddings might hold up better. Who else is building a company mind?
Experience & Education
-
Wild Earth Inc
View Antony’s full experience
See their title, tenure and more.
or
Licenses & Certifications
Languages
-
French
Limited working proficiency
-
English
Native or bilingual proficiency
Recommendations received
1 person has recommended Antony
Join now to viewOther similar profiles
Explore more posts
Explore top content on LinkedIn
Find curated posts and insights for relevant topics all in one place.
View top contentOthers named Antony Evans in United States
10 others named Antony Evans in United States are on LinkedIn
See others named Antony Evans