Twelve hours, a language I couldn't stand, and a graph I couldn't defend

I was in the building for thirteen hours and I finished my project in five. That gap is most of what I have to say about JacHacks SF.

Doors at eight. The opening keynote from Dr. Jason Mars, who created the Jac language, ran until 10:30, so that's when I actually started building. I had a working MVP by four. Judging was at seven. Finalists weren't announced until nine. Which means I spent three hours polishing and rehearsing a pitch — a luxury I have never once had at a hackathon, and more time than I needed. The venue is a 42,000 square foot campus on paper; in practice there were people standing at tables because there was nowhere to sit. I skipped the lunch line entirely and bought food from the farmers market out front, because it was faster.

▸ view venue-sign.jpg

## What I built

OrgMem. The one-line version I came in with: graphRAG that doesn't suck. The real version: a digital twin of an organization, so an agent can have the kind of organizational insight a decent middle manager has — who knows what, where it's written down, and where it isn't.

I took the orgforge dataset off Hugging Face — 46 people, about 5,000 artifacts, 11,000 events across 60 working days of a simulated company — and used the metadata already sitting in it to build a graph. Then I wrote traversal tools on top of that graph, and handed the tools to an LLM in a chat panel.

▸ view mvp-morning.jpg

The thesis I liked then and still like: a graph can prove a negative, and top-k similarity can't. Vector search finds you the most similar thing that exists. It cannot tell you that a postmortem was never written — a miss and an absence look identical. Walk a bounded region of a graph, count zero, and you have established genuine absence. On the benchmark's silence category that was 96.3% against a 55.6% baseline.

I also built graph visualization with artifacts rendering out of the nodes, animated the traversals so you could watch a walker move, and put a marketing site on the front that doubled as something I could scroll through to introduce the project. All of that was aimed squarely at a wow moment in front of judges, and it worked — they liked the animations, the chat panel, the site.

## What I actually took home: graphs

At my last hackathon I learned what observability means. At this one I learned graphs.

That wasn't an accident. In the week of nights leading up to this, I went through the previous JacHacks winners and noticed that every single one of them put the graph primitive at the center. So I spent those evenings on graph theory instead of on my idea.

Two things made it click. First, asking Claude to build me animated demo pages — watching a traversal run beats reading about one. Second, asking it to map graphs onto something I already know cold. It walked me through how design rule checks in ECAD tools represent a netlist as a graph and use that to find hanging nets, and that landed instantly, because I've stared at that exact failure a hundred times.

What I believe now: turning your data into a graph doesn't solve a problem, it hands you a toolbox. Pathfinding, connectedness, bottlenecks, orphans, reachability — all of it comes free the moment the shape is right. You reach for a graph when the questions you're asking are about relationships rather than contents.

## The Jac language

The pitch is genuinely good, and I want to say that first. One language for backend, frontend, and AI — Python and JavaScript and C all landing in the same environment. Graphs as a first-class primitive, with nodes, edges, and walkers built into the syntax. byLLM as a language-level thing, so calling a model is a function call instead of a glue layer. Persistence for free, keyed to reachability from root — no database, no ORM, no save calls. If you're building agentic systems, that's a real reduction in moving parts, and fewer tokens burned gluing them together. One language to rule them all. We've heard that before, but the graph and byLLM primitives are a genuinely fresh argument for it.

The implementation fought me for twelve hours.

The docs and the compiler did not agree. Repeatedly, and not on edge cases — on signatures, on behavior, on features that flat out did not exist in the thing I was compiling against. I had spent evenings that week pulling and distilling the entire doc set into an LLM wiki so my agents would have clean reference material, and it turned out to be worthless, because I had very carefully distilled a pile of errors. The MCP server didn't help. There was no editor language support pack. So the loop became: read the docs, get it wrong, read the compiler source, guess, build, repeat.

▸ view celsius-terminal.jpg

Here's the part I can't get past. This is a language whose entire pitch is that it is AI-native. The primary consumer of your documentation is a model. And the documentation is wrong. Put an agent on CI that regenerates the docs when the compiler changes. That is an afternoon of work sitting directly under your whole value proposition.

I also wasn't alone in this. The sentiment was everywhere on the floor. One team wrote their entire project in Python and ran it through a Python-to-Jac converter they found on the internet.

Hosting had its own version of this. The event pushed you toward JacHammer, their all-in-one platform, so that judges could open a live URL instead of crowding around a laptop. I never got it to work. My build died on their infrastructure with an import error thrown by their own error reporter, and after enough rounds of that I gave up and pushed to Railway instead — which handed me a 502 about an hour before judging.

▸ view jachammer-fail.jpg

▸ view railway-502.jpg

What I think a new language like this actually needs isn't better docs — it's a fine-tuned model that already knows the language. Give me something that writes Jac natively and I never have to open a page. Until that exists, every hour I spend on your syntax is an hour I'm not spending on my idea.

I have never created a programming language or started a community around one, so take that for what it's worth. Maybe it gets there. I'd bet against it.

## Where I lost it

The judges liked the demo. Then they started asking questions.

“If you had to edit data in the graph, how would you do it?” My answer was that nodes only ever get added, never edited. They did not love that answer. Then they asked how the traversals were implemented, and I couldn't really answer, because I don't know graph algorithms that deeply and I hadn't written them. I got a chuckle when I admitted it was Claude that wrote them.

It was a real laugh, and it was also the entire problem. I had learned enough graph theory to know why a graph was the right shape for my problem. I had not learned enough to defend the implementation when someone pushed on it. The demo is what gets you into the conversation. The questions are the actual test, and that's where I got taken apart.

## Losing to ants

There were ten judging groups with eight projects each. Trails came out of mine.

Three high schoolers built it. The idea is stigmergy — five agents walking an evidence graph like ants, leaving pheromone trails on the connections they find useful instead of talking to each other, pointed at fraud investigation. Traction took first in the Agentic AI track; Trails took second.

Do I know exactly why it beat mine? No, and that's the part I'm still chewing on, because I can't fix what I can't name. My best guess is that theirs was one idea, in one domain, with a reason the graph had to be a graph. Mine was a very good graph looking for a room. Or maybe I just answered the questions badly. Probably some of both.

I still think OrgMem is a strong project and could be a real product for small and mid-sized companies if someone executed it properly. That belief and two dollars gets you nothing at a hackathon.

## A room full of high schoolers

A lot of this event was high schoolers and incoming freshmen, and I mean that as a compliment. Wirejac was four of them: a coordinator agent that takes a change request, builds an impact plan, and routes work through separate client, server, device, deployment, and monitoring workspaces — down to an ESP32 running MicroPython and collecting accelerometer data. Full stack plus firmware, in a day.

That's not a toy. They are better with these tools than most working engineers I know, and I don't think it's a fluke. They started here.

## What I'm taking

Didn't place, again. What I walk out with is graph theory, a very strong opinion about developer experience, and one specific correction to make: build the wow, yes — but know the thing underneath it well enough to survive four minutes of a stranger poking at it. The demo opens the conversation. It doesn't finish it.

Also, thirteen hours is too long. Whatever the eight-hour version of this event looks like, it's better.

See you at the next one.