Good enough wasn't

The last post here that anyone was told about went up in January. There is one after it — about “Ghost Repos” — GitHub repositories with hundreds or thousands of commits, real tests, real CI, and almost no stars. It’s dated the sixteenth of April. Nobody was told about that one. It went live when I moved the site from being all about CodeWeaver to ‘Something new is coming’. I never announced it, never posted it anywhere, never did the thing you do after you publish.

So it sat there. A long piece about dedicated projects nobody has heard of, which nobody has ever heard of. That felt right.

I wrote the first draft in March. The goal: get to the front page of Hacker News and bring people back to Knitli, which then meant CodeWeaver. I think it would have worked – it is genuinely new and interesting analysis about a topic everyone there cares about.

Around the same time I started looking at something else. I meant to give it a week.

That was five months ago.

The uncomfortable part

I have wanted to tell you about what I have been working on since April. Really. Sitting on it has been the least comfortable part of the year. Every piece of advice anyone gives a founder says announce early, ship rough, and let people watch it improve.

I had a version working in April. It was right most of the time.

This was different. I was solving a problem that is like an annoying buzz in the background of every intelligence career. A problem most people think must always be handled by humans alone: the classification problem. If you aren’t a current or recovering member of the National Security community, the problem: classifying information consistently and correctly is really hard. Every study, review, investigation of it has concluded it is done wrong more often than right, and never done well.

Most of the time is a fine bar for a lot of software and the wrong one for this problem. I could not tell you, with confidence, that a given answer was correct — and usually right, handed to someone with no way to check, is how you get the problem I set out to fix in the first place.

I could ship a tool that was usually right, or I could ship one that could be checked and exceptionally right. I only wanted to build the second one, and it is the only version that can address the problem.

So I did not announce it. I spent another four months making it correct, and giving it the ability to explain itself.

What that bought

It still has bugs. All software does. But its rule-bound results are reproducible and can be checked against their cited authority. That is what I mean when I call it correct.

The program I built four months ago couldn’t have done that. When it was right, it was right because of brute force, and it had no concept of why it was right. What I have now is different. What today’s version does is more like finding the only way a puzzle fits together. The other thing it does well is tell you what it did and why.

That is what the extra time was really for. Not polish — giving it a voice.

What it is

It is called Marque, and it’s a corrective marking compiler. It validates, resolves, and corrects classification markings, and it shows its work. It can give live feedback inside a marking tool, run as a batch or ETL stage, or check inputs from human and probabilistic systems.

• Deterministic. The same input, build, and configuration produce the same marking result.
• Marking-focused. It applies a marking grammar rather than making a semantic classification determination. Recognition can inspect bounded context when the marking structure requires it.
• Operator-controlled. It does not phone home or default telemetry to Knitli. Air-gap, egress, audit storage, and retention are properties of the deployment around it.
• Accountable. An authority or authorized upstream process supplies the semantic facts. Marque makes the rule decisions that follow; genuinely unranked alternatives are returned, not applied.

It is patent pending, it is genuinely novel, and I am prouder of it than of anything else I have built and can tell people about.

It is also, deliberately, not probabilistic. That is a division of labor, not hostility to AI. A probabilistic system can interpret content, extract facts, or recommend controlling inputs; Marque can sit downstream and make the reproducible, rule-cited marking decisions those inputs require.

The classification system was never wrong. It asked too much of the people running it. Much of that burden is structured rule reconciliation rather than semantic judgment, and it should have been computed all along.

What changed my mind

Here is the part I did not expect. I didn’t think the classification problem was solvable. Not “hard” — not solvable, the way some problems are just the cost of doing a serious thing. I set out to build a better tool to make marking documents a little easier, which is a much smaller ambition, and somewhere in the five months it turned into something else.

What Marque actually is, in use, is the engine that automates the rule-bound part: the hundred pages of interacting rules, the cross-references, and the arithmetic. It can do that live while a person marks a document or at collection scale inside a pipeline, leaving attention for the semantic determinations that really require it. Marque frees people from straining at something people were never built to do, and it turns out that when you take that weight off, what’s left is tractable.

The answer to the whole problem is reachable now in a way I did not believe it was in March. The reason is narrow and specific: the marking layer can now be deterministic, testable, and rule-cited. You can build a great deal on a foundation whose decisions can be checked.

Marque is the start and the flagship, and it is my down payment on the larger problem. I intend to keep going at it until it is truly solved.

Whether I was right to wait

I don’t know. However you count it, 4 or 7 months is a long time to be invisible, and I have watched the cost — the silence, the reasonable assumption that Knitli folded, the ghost post nobody read.

What I am sure of is that shipping a version I could not vouch for would have been a perfectly good startup decision and the wrong one. Not because it would have embarrassed me — because none of what I just described would have been true, and I wouldn’t have known.

If you were here before

You followed me for developer tooling — parsers, context windows, embeddings, code review. That work was real, it is all still here, and nothing has been deleted or quietly rewritten.

This is less of a jump than it looks. I spent a long time on grammars, on parsing things never designed to be parsed, and on the gap between what a tool says and what it means. I built real expertise on natural language processing (NLP) with CodeWeaver. Enough to know it wasn’t the right tool for this job, which people who follow the problem seem to assume. Marque is a compiler for a grammar that happens to be written in English, sits in the header and portions of a document, and has tremendous consequences when you get it wrong. A simple marking mistake can kill. Same instincts, much higher stakes.

My original projects, CodeWeaver and Thread, are dead. Great tools; they solved real problems. Available for anyone to pick up and run with. Marque is Knitli’s future.

And if you want the post I never told anyone about, it is still up. It even has its own website. The last thing I finished before all of this took over. I have come around to thinking it belongs here exactly as it is.

I probably won’t mention the post again. It feels right that people should just find it on accident like the projects it highlights.