Writing

I paid for five AI coding subscriptions and could only use one at a time. So I built a model catalogue, a health-checked proxy, role-based launchers, a worker back-channel and a dashboard to orchestrate them together.

Before an agent can hand off a job, it needs four answers: what it can use, whether it works now, whether this job may use it, and what happens when a worker gets stuck. Those answers have to come from the machinery, not from instructions the agent may forget.

dbt brought Git, tests, and review to warehouse SQL, and that was a real achievement. But governing hand-written code is not the same as needing to hand-write it. An investigation from the platform side of the fence.

For three years I pitched Exasol on a PostgreSQL front-door so driverless tools like Qlik Cloud could reach it. When a proof of concept got cheap enough to just build, that became the argument that finally moved the vendor. The happy path is a weekend now; the edge cases cost what they always did.

For thirty years the analyst who built the number was its audit trail; automate them away and lineage is all that is left. You can rebuild that trail by hand across a modern data stack, but it is tedious work almost nobody does, whereas an integrated platform gives it to you automatically because one owner holds every hop.

People reach for vibe coding to avoid learning how software works. The surprise is that directing an agent through a real build teaches you more about APIs, data shapes, and failure modes than they ever meant to learn. A lopsided, practice-first education that arrives through the side door.

Data contracts have been sold for years as producer-consumer paperwork. Once an agent is a consumer, they stop being documentation and become runtime safety rails, because the agent is the one consumer that keeps going when the data changes underneath it and returns a confident, well-formatted, wrong answer.

Eight months ago I gave up on a little arena shooter because it got too complex to be fun. Picking it back up with much better models, the rebuild was fast in every way an agent is good at, and the game still wasn't fun. AI cleared every obstacle in the build except the one that mattered.

A warehouse tells an agent what a number is; it rarely tells it what the number means, who owns it, or what changed last quarter. Closing that gap is what turns a warehouse into a knowledge base, and most of the work is metadata, ownership, and vocabulary rather than machine learning.

Modern agents are excellent on the well-trodden path and revealing on the path that isn't. Point one at a 1986 Amiga raytracer or a hand-rolled glyph renderer and you find out fast what it understands versus what it's pattern-matching toward, and you have a very good time doing it.

If an agent can assemble the view a question needs and throw it away afterwards, the curated dashboard loses its monopoly on the front door to enterprise data. The platform's value moves down the stack (to the model, the metric definitions, the APIs, and the governance) and the work shifts from building screens to deciding what the numbers mean.

I defaulted to the frontier model and watched it bill its way through work a 5B model would have finished in a blink. Routing well turns out to be about capability fit, not cost, and the skill that lasts is decomposing the work so the model almost picks itself.

The internal tool a vendor quoted at €40k often dies because nobody can justify the spend. Many of those builds are now a weekend. But the invoice was never only paying for code, so the trick is knowing which part you've replaced and which part you've decided to live without.

For twenty years the semantic layer was a reporting convenience. Now it's the context an agent reads before it answers, the platinum layer above your gold tables, and the new questions are where it lives and who owns it.

Building software used to need a reason that survived someone else's scrutiny. A business case, a roadmap slot, a promise to maintain it. For a tool only you will ever use, that bar is gone, and the gentlest, most freeing kind of building is the one nobody asked for.

Agents are not replacing software teams or idling beside them. The working unit emerging in 2026 is a mixed team, and the hard parts sit in division of labour, review, and who answers for what an agent shipped. What the consultancies are selling, what their own surveys measure, and what it means for anyone who builds software for other people.

Databricks open-sourced Omnigent, a layer that sits above coding agents like Claude Code, Codex, Cursor and Antigravity and treats each as a swappable part. What makes it interesting is what it coordinates, other people's finished tools as swappable parts, and how neutrally it does it.

AI writes flawlessly, which lends unearned credibility to whatever data sits underneath. Bad quality is more dangerous when the answer sounds this good, and the fix is the unglamorous discipline of stewardship, freshness, and checks that produce evidence.

A working tour of what a large language model is, how it is trained, why dense and Mixture-of-Experts designs trade memory for capability, how you customise one, and what it now costs to build a small one from scratch.

We keep describing a statistical text predictor with the vocabulary of gods, hive minds, and sovereigns, and a small group is arranging itself as the clergy that guards it, controlling access, resources, and distribution. The reach for myth tells you more about the people reaching than about the technology, and the architecture going up around the temple is not the architecture of generosity.

On 12 June 2026 the US government ordered Anthropic to pull Claude Fable 5 worldwide, and the company complied within hours. When a single directive can switch off software you depend on, the cloud strategy you spent a decade building needs a counterpart, a plan for the day you are locked out of your own estate.

Open-weight coding models now land within single digits of last year's frontier, and the new developer skill is matching the model to the task rather than always reaching for the smartest one. But the premise that prices are rising is only half true, a flat per-token rate still hides a rising cost per task, and how good "good enough" is depends heavily on the human steering the agent.

The one-off script that joins two systems was never worth a developer's afternoon, so it went unwritten and people copied data by hand for years. Agents drop its cost to twenty minutes, which changes which gaps are worth closing, and quietly creates a maintenance problem nobody owns.

Coding agents now let a motivated non-programmer build tools that solve real problems. The capability is real, not a training-wheels version of it. So is the danger: the people the agents empower most are the least equipped to see when confident-looking code is quietly wrong or unsafe.

Tokenmaxxing is fading. Here's how I get better agentic output from a smaller token budget, and why the answer isn't to swap one vanity metric for its mirror image.

Thirty years of modelling discipline is being diluted just as agents start reading our tables directly. The case for why grain, conformed dimensions, and an owned glossary matter more now, not less.

Microsoft and Google will win workplace AI on distribution, context, and governance rather than model quality, while large SaaS platforms like Salesforce turn headless. As the interface becomes something agents generate per task, enterprises start buying validated data models and APIs instead of UIs, which reshapes the choice between vendors like Salesforce and Dynamics and the line between building and buying.

The agentic boom of late 2025 and early 2026 was driven less by smarter models than by the scaffolding around them. A guide to what a harness is, where the idea came from, and why it now decides more than the model.

Snowflake and Databricks are often treated as default choices for enterprise data work, but "default" and "necessary" are not the same thing.

Snowflake, Databricks, and Microsoft Fabric in 2026, with a Norwegian/Nordic lens on sovereignty, Iceberg, and the DuckDB phenomenon eroding cloud warehouse economics from below.

A non-web-developer's account of building an 87k-line notes app by directing coding agents, and why the most useful part turned out to be the CLI and MCP server that turn plain Markdown notes into shared infrastructure for humans and agents.

The developer's job isn't disappearing. It's being hollowed at the bottom and elevated at the top. The harder question is the pipeline: if juniors never write code, where do the next seniors come from?

When to leave a legacy database, how to weigh a new platform, and what I think the next generation looks like.