ossianericson

I daily for work (and private) use AI to develop this I hope will save me some time, Will test and cross reference when I work this week to see what gems I might have missed.

Strong for the downstream part.

Upstream rules should travel with your repository, never be locked to just one agent. I want to experiment, test different models.

I could never work in one model, it requires specific parts that work only in that specific snowflake implementation.

I remember two decades back when Games for Windows was introduced with Vista, I wrote an article that this was killing gaming. As a PC (master race) gamer back then, I didn't always find it appealing to think that PC games had to have gamepad support etc. To be called and have the Games for Windows logo.

Now seeing Linux just absorbing Windows APIs into the kernel to make gaming work better? That is the opposite direction. This is what PC gaming needs.

I got into PC gaming when I got my Ambra Hurdla SX25 in 1992. Back then it was the fantastic era of first for everything. We got Comanche, Alone in the Dark, Dune, Dig, etc. First of all game types, not just clones of the same concepts.

Cool I like it! Guns and a map? Now I want to play Jagged Alliance.

This type of content would never cross my path normally , way outside my skillset. But it is stil interesting and exactly why I keep coming back to HN.

Had a 486 SX/25 (Ambra Hurdla) back then. Accidentally bought 4x4MB server SIMMs instead of what I needed and ended up with 20MB which was kind of absurd in 1993. Ran the whole games directory as a RAM disk just because I could. Spent way too long learning the segmented memory model by breaking config.sys rather than reading anything. Would've been useful to have the actual source back then.

The OIDC federation between the runner and the cloud resources it touches , that credential gets created once. Permissive enough to not block the first deploy, and it is not what is reviewed when a pinning incident happens. Every one is looking at the action. The identity it runs as just sits there.

The friction Cantrill describes does not go away, it just moves. In my experience, if you don't do the "lazy" thinking before the model touches anything, you pay for it when trying to maintain something you didn't mentally build. The spec becomes the place where the laziness discipline has to live now.

The CDN part is the easy half. In my work the harder problem has most often been internal service mesh, mTLS between services, any infra that doesn’t terminate at a CDN. Has a bad habit of longer certificate lifetimes and older TLS stacks, and nobody is upgrading it for you.

Maybe I am misreading this but it looks as alwaysGrants bypasses the rest of the controls.

I would say that when you treat your Markdown as the authoritative source, I of course don't get it automated but that is my choice. It takes knowledge of the domain, but when you have deep specific knowledge that is worth so much more than automated updates. I use AI to get the initial MD but then I edit that. Sure it doesn't get auto updated, but I would never trust advice on the fly that got updated based on AI output on the internet.

The load-bearing line is buried near the top: “On projects where I have no understanding of the underlying technology, the code still quickly becomes a mess of bad choices.” That’s not a caveat.

That’s the precondition the whole system runs on. The failure mode is invisible. Bad architecture doesn’t look like a crash. It looks like a codebase that works today and becomes unmaintainable.

The Dictator's Handbook explained this in 2011: corruption in autocracies is the governance model — it's how you pay a small winning coalition to keep you in power . So citizens aren't surprised by it, they're just not in the coalition. The paper's contribution is putting a multilevel regression on what Bueno de Mesquita already drew as a diagram.

The pattern I've seen isn't that AI can't do the work. Challenge is if an org cuts the people who held the context, not just the people who did the tasks. The tasks came back looking fine. The decisions downstream of those tasks didn't. You can automate execution. You can't automate the judgment that came from five years of seeing what broke last time.

The AI extraction + deterministic scoring separation is exactly right, and the reasoning holds beyond SOW analysis. I hit the same wall building internal decision tools: LLMs are useful architects but terrible engines. Same principle — AI reads and structures, deterministic compiler owns the output. Same input, same result, traceable, auditable. The governance argument alone justifies the split even before you consider reproducibility. What does your scoring engine do when the AI extraction is ambiguous or incomplete — does it fail loudly or degrade gracefully?

The "deterministic as fallback when agents get flaky" framing resonates. In infrastructure I've found the same pattern — the agentic approach gets you started fast but you eventually rebuild the critical path as something reproducible. The HAR + structured JSON export is smart, it means the knowledge of what the automation does is owned separately from the execution engine.

The read-only past is the right constraint. There’s a broader principle here — immutability forces clarity. You stop optimizing the past and start writing for today. The local-first + deterministic output pattern resonates. I’ve been exploring the same instinct in a different domain: using a compiler to produce reproducible HTML from a spec, so the output is always the same regardless of when you run it. Different problem, same underlying distrust of runtime variability.