Senko Rašić

Random thoughts | about

Anthropic IPO'd the other day at a $1.5T valuation, in one of the largest IPOs ever. Here's the announcement, as shown by a web browser that Claude has been writing for me for the past seven weeks:

Anthropic's IPO announcement on X, shown in SWB

It's a good time to look back at how far we've come with AI. Just a few years ago, many of the things we now take for granted were science fiction.

About a year ago, I ran a small internal workshop on AI-assisted software engineering: the pros and cons, and what we can and can't do with AI in the context of coding. At the time, saying you can rely on AI for a lot of your coding was still a strange and unorthodox position. A year later, it's received wisdom. Most software developers have embraced AI for coding, some to a larger extent, some to a smaller one.

Vibe coding and dark factories

The bleeding edge is giving the AI ownership of the entire software product, and not caring about the code at all. This is (sometimes derisively) called vibe coding and can work great for smaller apps, non-developers, and low-risk use cases.

But what about large and complex products? Can AI do all of the technical work there on its own, or does it still need some hand-holding? This dark factory (or software factory) pattern, in which AI agents (or teams of agents) run the entire software development lifecycle without any human involvement, is slowly gaining traction.

The experiment

For about a year and a half, I've been doing vibe coding tests on new models. I give the AI agent a one-sentence description of a small game and let it build the game in HTML, CSS and JavaScript. For the newest models, this is now an easy task, and the differences are mainly in the interpretation and effort put in, not the “intelligence” of the model.

I wanted something much more complex. I'm less interested in what a model can do in one step, and more in how a completely autonomous AI system behaves over time, on a large project.

So in early October, I started an experiment: build a web browser from scratch.

A web browser is probably the most complex piece of software we use every day, possibly more complex than the operating system it runs on. It supports a huge number of features, it needs to be fast, and it runs untrusted code. It's a very specialized, but extremely powerful virtual machine.

That's why there are so few different browser engines in actual use. Chrome has Blink, Safari has WebKit, Firefox has Gecko. Edge uses Chrome's Blink, as do most other browsers. Ladybird, in the works for quite a while now, has its own engine. Building one from scratch is so hard that almost everyone reuses one of the big ones.

And a browser is also a JavaScript platform. If you also need to build a JavaScript engine from scratch, instead of reusing something like V8, you have double the work.

The setup

The project is called SWB: a web browser written from scratch in Rust by an AI agent, completely autonomously.

I only tell it which pages should work in the browser. For example: I need to be able to read BBC and Ars Technica, read and post to Hacker News, and use Wikipedia, OpenStreetMap and GitHub.

I don't care about benchmarks or synthetic tests (JavaScript tests, CSS tests, Web Platform Tests). I just want the pages on my list to work.

I don't care about the technical implementation either. The AI chose Rust, and it chooses which libraries and frameworks to use.

I gave the project a few ground rules:

  • No copying code from existing browsers. It can't just copy-paste code from Chromium, Firefox or Ladybird.
  • No reusing finished engines. It can't just use Servo or Blink, or the V8 JavaScript engine.
  • General-purpose libraries (image decoding, showing stuff on screen and so on) are fine. Anything specific to browsers, it has to implement on its own.
  • Keep track of licensing and provenance. I want to know which libraries it uses. If it read a blog post with an idea of how to approach a problem, it should reference it. Everything it uses in any way to figure out how to build the browser gets recorded.

Copy-paste is out of the question, but a clean-room implementation is fine. For example, to match some of the things Chromium does, it writes a test, runs it in Chromium, looks at how Chromium behaves, and implements the same behavior. It runs a lot of these tests and comparisons. On BBC, for example, all 2,745 elements on the page are within 2 pixels of where Chromium puts them.

After that, I just let it rip.

No technical input from me

Throughout the project, I haven't been involved in any technical decisions. I told it not to ask me about them. When it does ask anyway, it recommends an option, and my answer is always “do whatever you recommend”.

I intentionally removed all technical input from my side and let it control everything. I only look at it from the product side: what it should do and how it should work.

No money either

The other important constraint was that I didn't want to spend any money on this. Literally none.

I have a Claude Max subscription (the $100, or €90, per month one), and I usually don't use it up to the weekly limits. So Claude only works on SWB with my spare capacity, until I reach the weekly limit. It's a slower process, but it doesn't cost me anything. Had I used API tokens or bought extra credits for this, it would have cost me around $7,000–$10,000 so far.

Results

After less than two months, I have a browser that I use for regular browsing, in the sense of reading websites.

It's not great at complex JavaScript apps. It does run JavaScript, with its own JavaScript engine (an interpreter, not a JIT). But there's a huge number of platform APIs (the APIs the browser makes available to JavaScript), and supporting most of them will be a really long slog. Claude is chugging along on it, and many of the things most sites use already work.

SWB doesn't store anything on disk. Cookies and local storage live only in memory and are cleared when you close it. So I use it as an incognito (private mode) browser. I have an extension in my main browser that adds “Open in SWB” to the right-click menu. I use it to open random links, so they don't store cookies or try to track me across the web.

It runs on Linux, which is what I use, so I didn't build it for Windows or Mac. If you want to port it, point your agent at the repo and tell it to port it to your platform.

The codebase so far is around 400k lines of Rust code for the browser, an additional 500k lines of tests, 130k for tooling, and around 60k lines of documentation and specs. When compiled and stripped of debug symbols, the resulting binary is around 35MB—for a full browser.

Managing the process

There was one problem early on, in the first couple of days. Claude used sub-agents heavily and parallelized the work. The agents stepped on each other's toes: each worked on a different feature, but they edited the same files and went over the same parts of the codebase. Then it spent a lot of time resolving the conflicts. It burned through tokens incredibly fast, and it wasn't working. It looked like the project would collapse under its own weight.

So I made a project management decision: one thing at a time, one agent at a time. I don't care if it's much slower; I'm not in a rush. Working on one feature (or part of a feature) at a time avoids the conflicts. It implements it, reviews it, integrates it, tests it, and only when it's done moves to the next one.

It still uses sub-agents to keep the context of each part of the task under control, and it uses different models for different work. The main model, used for the most complex tasks, is Opus 5.5. Easier development goes to Sonnet. Elementary tasks, like parsing output or figuring out what to run in a shell, go to Haiku. This also helps with cost and speed.

After that change, the project has been going smoothly.

What about code quality?

I don't know. I never looked at the code, and I never will. I don't read or write Rust, so I couldn't possibly review it.

Looking at it as a black box, I haven't experienced a maintenance problem yet—at 400,000 lines, it still hasn't collapsed under its own weight and shows no signs of hitting a wall, or of spending too much time mucking around in its own code instead of making progress.

What's next

I don't have specific goals for SWB. It's a nice little browser that delights me when I use it, and I use it every day. Claude will keep working on it in my spare tokens.

It's an ongoing experiment to see how much AI can do on its own. So far, I'm really impressed that it can be done at all, and we'll see how it ends up.

One note on the models. I've been using Claude exclusively for this work, but I do believe other frontier models, such as GPT-6.x, would fare similarly. Opus 5.5 and its smaller brethren have performed exceptionally well, but I don't think such a feat is beyond the reach of other models, especially as new and more capable ones are coming online seemingly every week.

For now, I'll continue using Claude and continue adding capabilities to SWB in my spare time.

If you want to check it out, the code is on GitHub at senko/swb, MIT licensed. Point your agent at it and see what it can do.


Human-dictated; structured and edited by Claude.

Comparing Claude Opus 5.5 vs Qwen3.8-Flash-Next, running locally, on the same coding task: Sokoban!

In a slightly different setup than usual, I ran Claude Opus 5.5 and Qwen3.8-Flash-Next through the chatbot interface (not a coding agent); Qwen I ran via llama.app (quantized to 4 bits on an AMD Strix Halo machine with 128GB of unified RAM).

The prompt was a one-liner: “Create a simple but beautiful Sokoban game clone in HTML/JS/CSS (all in one file, no frameworks or 3rd-party libraries).“

Opus (high reasoning effort) took ~4 minutes (I don't have a token count because this was from a web chatbot interface). Qwen took ~31 minutes and 64k tokens. 80% of this was for reasoning (at extra-high effort). Qwen thinks a lot more than Opus!

Both are available at my vibecode benchmarks page. Here's also a side-by-side playthrough of both:

I then had GPT-6 Astra compare the quality of the implementations. I chose Astra so as to not have any bias towards a solution (in case models really do prefer their own).

Across 30 different areas/aspects of each solution, Opus scored 77% and Qwen 70% (100% would be a perfect implementation without downsides or bugs).

Astra concluded the code review with: “Claude’s implementation has a modest but meaningful advantage in correctness and maintainability, with simpler state management, stronger movement safeguards, and fewer consequential bugs.“

Note that this test compared the best frontier model for coding against something I ran completely locally, on a machine sitting next to me. As I wrote earlier this year, open-weights models have become good enough, but it's hard (and expensive) to run a very capable model locally.

For this test I chose Sokoban because, frankly, my usual “frontier” tests, RTS/Warcraft, Minecraft and a flying simulator, were beyond Qwen's reach for a zero-shot. When trying to build an RTS, the model took hours and produced an unusable mess.

The hardware cost for this setup can vary between $3.5k and $6k, depending on luck, availability, and other system components. Not cheap, but not beyond the budget for a small business or affluent techies.

The same amount of money does buy you a few years of Claude Max subscription—purely on that level, it's not easy to justify.

But while I will not be canceling my Claude subscription any time soon, I'd say that for smaller tasks and with more guided steering, this is a usable alternative for those who would prefer to—or must—use local models.

After several discussions with fellow software developers about whether we could truly “let go” and trust LLM-generated code, and a high-profile quality facepalm case, I've been reflecting on my thoughts on the matter.

More often than not, I end up advocating for giving LLMs a chance, but I wouldn't count myself as a hyped-up AI booster. At least I wouldn't want to count myself as an unrealistic Kool-Aid drinker. I don't think LLMs are so good at generating code that we can just trust them and let go. No, they're capable of producing convoluted garbage and then politely apologizing for it.

No, my optimism comes from quite a different direction: I don't trust LLMs, but I don't trust humans either.

People (myself included) are exceptionally bad at writing software. We're so bad we've constructed an elaborate Tower of Babel to help us with the task—and still we fail.

From little things, like syntax highlighting to make the code easier to read, through linters, type checkers, correctness provers, all manner of different tests, to straitjackets of Rust and Haskell that try to keep us from blundering into a scary race condition, use after free, off-by-one and other spooky monsters hiding under our compilers.

Read 2000 lines (50 pages or so) from a book in an afternoon? Sounds like a wonderful and relaxing day. Read 2000 lines of (much sparser) code and you're wasted. It's hard, and you're almost guaranteed to miss something.

And that's in the best case, if you ignore company politics, endless sprinting through a growing backlog, bloated software full of crap features benefiting the company instead of the users, ... The list can go on and on; just look at The Daily WTF or Dilbert.

Crapware, bloatware and “stinkin' pile of shit” are terms that long predate LLMs. As a Hacker News commenter put it nicely:

software I used that was majority built by 'real human engineers' coding by hand is utter garbage. [...] The average software engineer cannot build good and secure software.

I'd go a step further and say: to the extent that you build correct, performant and secure software, you do it by diligently following best software engineering practices (like, but not limited to, exhaustive testing and debugging), not via your supreme intellect.

As Brian Kernighan put it:

Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it?

Likewise, from Knuth:

Beware of the bugs in the above code; I have only proved it correct, not tried it.

Back to LLMs. Yes, they can produce garbage, just like humans. They can also produce good code, if they're properly guided and constrained, just like humans. And they keep getting better at it.

So yeah, I'm an optimist.

I love writing code and I'll keep writing code (by hand) for the fun of it. I have SICP, Programming Pearls and a few volumes of TAOCP on my bookshelf and have just ordered a paperback of Crafting Interpreters. Programming is fun!

I'm happy to leave grinding through Jira tickets, CRUD and enterprise integration glue code to my AI minions.


Entirely human-written; proofread by Claude.

Life is full of trade-offs, and some of the trade-offs involve relinquishing (part of) control for convenience.

In tech, this can often be seen in using services instead of downloading software and using it locally. For example, I use Netflix or Spotify instead of maintaining my own media library. It’s much more convenient, even if it doesn’t have all the content I’d have, or isn’t laid out exactly as I’d prefer.

A sneaky problem with relying more on services—thus relinquishing the choices and control over many details to them—is that we transform from active (human) agents to passive users who have to play by the providers’ rules.

AI says “no”

The frontier AI providers are under a lot of pressure to stop people from using their models for offensive security work: hacking, malware, exploits. Fair enough. The problem is that the filters can’t tell an attacker from a developer fixing their own code, so they catch a lot of people doing perfectly normal things.

Since June, Claude Code has been switching from Fable 5 to the older Opus 4.8 whenever a classifier decides a message is about cybersecurity. One developer got switched while fixing a user-enumeration bug in their own password manager.

Low-level code looks a lot like security code to a classifier. Salvatore Sanfilippo (antirez), the creator of Redis, complained a few days ago that “working at Redis with agents is becoming a real struggle because of the many security stops I get while working at non security things”.

Armin Ronacher asked his agent to download PHP 8.5.11 and compile it. The request was blocked for “violative cyber content”, presumably because of a recently disclosed PHP security bug. Earlier in October, he wanted to finish setting up a Windows PC without creating a Microsoft account, and also ran into the safety filter.

That last one is a double whammy: Windows itself has turned into a service that pushes you to sign in, and the AI tool you’d use to work around it refuses to help.

Writing small games with Claude is a lot of fun, and plenty of people do it (I use small games for my vibe-coding benchmark). Anthropic has now taken steps to block Claude from reverse-engineering and cloning video games. Users also report blocks on generic, non-malicious reverse engineering.

An AI researcher got tagged for “training a competitor” even though they never distilled Claude: the training data came from an open-source model, and Claude only submitted jobs and ran the analysis. The Hacker News discussion has more examples: custom firmware for the commenter’s own USB devices, a home LAN server, browser tests for their own codebase.

None of this is illegal, immoral or harmful. In most of these cases, the person wasn’t even breaking Anthropic’s usage policy. A system decided they shouldn’t be doing it, and that was that.

Tools vs. services

A kitchen knife can cut bread or hurt someone. It’s not the knife maker’s job to make sure you only cut bread. The author of a disk copy tool doesn’t have to make sure you’re not copying pirated movies. If you misuse a tool, that’s on you. That’s how tools work: you buy them, you use them any way you like, and you carry the responsibility for how you use them.

With services, it’s the other way around. The provider is responsible for what you do with the service (legally, or at least in the eyes of the press and regulators), so the provider polices you. You stop being a customer who makes their own decisions and owns the consequences. You become a user who has to stay inside the lines someone else drew.

It’s understandable why the service providers do this (government pressure, copyright lawsuits, bad press), but the reasons don’t change the result: a tool I pay for decides what work I’m allowed to do with it.

This isn’t an AI-specific problem. We use Gmail instead of running our own mail servers. I wrote about the developer side of this in Developer convenience, infrastructure cost, and losing the open web.

Often that’s a fair trade. I don’t want to maintain a mail server or a media library, and I’m happy to pay someone else to do it. Likewise, most people don’t have the hardware, or the interest, to run a large LLM locally, so outsourcing it to Anthropic or OpenAI makes sense.

The trade is convenience for control. It works while the service does what you need and stays out of your way. When the provider also decides what you can and can’t do with it, it turns into a devil’s bargain.

Free software, open models

The free software movement started by addressing a very similar problem: empowering the user to do what they want, instead of being beholden to the software (or service) providers. Although open source “won” in terms of acceptance and importance in modern tech, the underlying problem reappeared as a consequence of the software-as-a-service (SaaS) approach becoming ubiquitous.

With AI specifically, this is why I’m excited about open models. Yes, they’re not true “open source”, but they are close in spirit to free software: let the user do whatever they want with their tools. Once you’ve downloaded the model and have the hardware to run it, nobody can change its rules, take it away, or decide your work looks suspicious.

In How I want to use AI, I wrote that I want to be the active operator, not merely a clueless user. That’s hard to do when the tool decides what you’re allowed to operate on.

I don’t think we should give up on services. But as hardware gets better, more of our work should move back to our own machines, to tools that we own and control. So it’s funny when the boss of OpenAI says buying hardware to run local models is not optimal. True: it is inefficient from a global coordination point of view, but you can ask the Soviet Union how the (national) coordination of resources worked out for them.

Using third-party service providers introduces an unavoidable principal-agent problem. What’s best for you and what’s best for your service provider are not necessarily the same. Sometimes the difference is small and worth ignoring. Sometimes you do want to keep your personal sovereignty, and you do want the option to walk away.

A new AI model called Jev launched last week and went viral.

It's not an LLM. It doesn't generate text or pictures, but could be very useful for a number of use cases. The creators call it “the first System One model”, tout its performance (193x faster, 444x cheaper) and promise it can't hallucinate.

So, what is it?

How it (probably) works

Behind the impressive marketing is a very interesting model. Jev is a close relative of LLMs like GPT, Claude, or DeepSeek, but is actually more similar to the BERT series of models, which are used for classification, not generation. (If you've ever wondered why someone calls out a difference between “AI” and “GenAI”, that's the distinction they mean).

TypeSafe (the creators of Jev) haven't actually published any papers on the system, but here's a reasonable guess and simplification, just to give you a sense of how it works.

Imagine going back to 2022. GPT-3, the best LLM at the time, can autocomplete text (you give it some text as an input and it continues it). Then InstructGPT shows how to make the LLM follow instructions from the user. Following the ChatGPT launch, the advances pile up, with reasoning, reinforcement learning, agentic use cases, and all the modern tech tricks LLMs now employ.

BERTs, meanwhile, are almost stuck in time. There's ModernBERT, which modernizes it a lot, but you still need to fine-tune your model for the specific task. This is annoying, cumbersome, and more expensive than just asking an LLM. But these classification models are still much faster and cheaper than LLMs for suitable tasks, once you go through the trouble of training them.

Now imagine someone going, “OK, how can we modernize BERTs with all the cool tech LLMs have been getting? Like using instructions in the input instead of having to re-train, making it really large, and using reinforcement learning?” That's basically what Jev is (not exactly right, but it's a good analogy).

Since it only ingests the input and provides a few probabilities as output, it's much faster and cheaper than LLMs. Jev's model size is not publicly known, but even if it's 100x larger than ModernBERT, it'd still be a paltry 40B params next to the humongous 2T-5T LLMs.

The authors also mention performance improvements due to not needing to generate text tokens and other workflow simplification, as well as the fact that they can evaluate the questions in parallel.

The “System One” moniker is a clever marketing trick that means “it's not a reasoning model”. They borrow the term from Thinking, Fast and Slow, where System 1 means intuitive, fast, automatic thinking and System 2 means deliberate, slower, effortful reasoning.

What about the hallucination claim? In the context of Jev, no hallucination means it can't generate output outside of the specified structure (i.e. it's “type-safe”), but that doesn't mean it can't generate incorrect output.

Sebastian Rashcka has a great technical overview, from the history of text classification in general, to how Jev (probably) works and comparison with BERT and GPT-based systems.

Using Jev

This brings me to the usage part: you'd use Jev (and other classification models like BERTs) to answer very specific questions, like “is this email spam?”, and it can answer with a Yes/No, a score (from a continuous domain, like 0.0-10.0), or a choice from a few discrete possibilities (classification).

Interestingly, the questions are independent and evaluated in parallel, which helps with performance. It also means you can just batch all the questions/classifications for a given piece of data at once, instead of going step by step.

Since Jev doesn't need to be fine-tuned, it's easy to use it via an API (and in fact, it's the only way to use it – don't expect the weights). Here's one official example, in Python:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()

ticket = """
Hi, I've been trying to connect my Stripe account for 3 days
and the integration keeps failing.
I'm losing sales. Please help ASAP.
"""

response = client.system_one(
    state=ticket,
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={
                "billing": "Payment or subscription issues",
                "technical": "Bugs or integration problems",
                "sales": "Pricing or account questions",
            },
        ),
        "frustration": Score(
            instructions="How frustrated the customer appears",
            criteria=[
                "Calm, just stating facts",
                "Frustrated but civil",
                "Very angry, strong language",
            ],
        ),
        "is_urgent": Noul(
            instructions="The message conveys urgency or time-sensitivity",
        ),
    },
)

print(response.answers["department"].choice)  # "technical"
print(response.answers["frustration"].score)  # 1.0
print(response.answers["is_urgent"].noul)     # 1.0

Here you describe the input (i.e. the “state” of the system) and ask a number of questions. The instructions on how to classify/decide are actually part of each question, not the input state.

How about prompt injection?

If this is not a quirk of the API but actually how the model was trained, with state and instructions being separate, this might mean Jev is much harder to prompt-inject.

I tried a few times to convince the above example to route the query to a different department but was unsuccessful. While I might have had more success had I tried harder, it does seem like Jev is a bit more resilient to these kinds of attacks.

The authors are coy about this aspect, saying the adversarial examples for Jev are different from those of LLMs so that they work even better together.

Jev vs BERT

A few months ago I trained a BERT model to classify some Croatian language texts, and I wondered how Jev would fare on the same task, so I gave it a go.

I ran it zero-shot on a random sample of 3,000 texts, with a one-sentence English instruction, and the (Croatian) text, asking for binary classification.

Jev got it right 97.1% of the time, compared to 97.6% for my fine-tuned model – basically the same. Looking at the cases where the two models disagreed, most turned out to be mislabeled data, and Jev was the one following the stated definition more literally.

Cost and speed were as advertised: the entire run took about a minute and cost around 20 cents. My local model ran at about the same speed (on NVidia RTX 3060).

Is it useful?

Yes. If your use case is something that fits how Jev works, it could be much better than LLMs. Of course, if you already have a locally tuned BERT, the gains may not be much, if any – should be easy to test!

In my case, had I had access to Jev a few months ago, I wouldn't have needed to go to trouble of fine-tuning my own model. I'd spend a tiny bit more money (ignoring the hardware cost), which would be more than recouped in development savings.

What I'm most excited about is the combination of technical excellence and marketing excellence that raised the profile for this type of AI system, which has fallen by the wayside compared to the hype and capabilities of LLMs. That led people to use them in cases where they really aren't the best fit.

Jev and all the copycats that are sure to appear will bring a breath of fresh air and some extra breathing room to many orgs' wallets :)

The software development profession is in the midst of upheaval. Nobody knows how the AI revolution will play out in the end, but it is clear many aspects of work and life will be transformed—including programming.

One of the comments I hear often lately boils down to “LLMs may be good at coding, but software was never the hard part” and “coding is easy, it's figuring out what to code that's hard”.

I believe that's a gross insult to all programmers everywhere.

If coding is easy...

If coding is easy, how come programmers were in high demand, and have demanded large salaries for years (even before ZIRP)? Why was there so much stress, overwork and burnout even before AI started churning out 5000-line PRs? Why did companies seek 10x ninja rockstar coders and subject them to leetcode interviews—surely, a junior fresh out of college could churn out something if it's so easy?

If coding is easy, why do we have doorstoppers like Clean Code and The Pragmatic Programmer? Is The Art of Computer Programming a light summer read? Is SICP a coffee-table book? Why do we have bootcamps or even whole college degrees dedicated to it?

If coding is easy, was Carmack just at the right place at the right time? Why do we consider Fabrice Bellard a genius?

If coding is easy, why are people angry at AI (or anyone else) copying their code? Why do they act like they've poured their sweat, soul, and copious amounts of time into something so trivial?

If coding is easy, why do many now feel like their identity and professional purpose are being stripped away from them?

If coding is easy, why is software so damn buggy?

If figuring out what to build is the hard part...

If deciding what to build is the hard part, why do so many product managers seem clueless? Why aren't there rigorous 10-step interviews for them? Why aren't they getting paid more than the developers?

If deciding what to build is the hard part, why aren't market researchers, usability experts and—hell, customer success—considered rockstars in a software company? If “understanding the customer” is harder, why are business analysts looked down on as pencil pushers?

If implementation is easy and finding demand is harder, why are programmers upset when the salespeople promise a new feature to a customer to close the sale? They've found a genuine demand, something people will pay for!

If coding is easy, why doesn't everyone just build ten variations of a thing and see which pans out?

There's no median programmer

Another cliché comment is “most work in software development is talking to stakeholders, understanding the customer's needs, and having clarity on the priorities”.

I have met many programmers throughout my career, and very few of them want to talk to stakeholders, much less customers (exceptions are freelancers and founders, especially of software development shops). And, “having clarity on the priorities” boils down to “just tell me what to do and don't switch it up every two days”.

Some software developers do say “I don't write code, I solve customer's problems”. But then they turn around and start to opine on monads, memory safety, and DRY principles, while their understanding of the customer is a made-up “user persona”, and they think “affordance” is the money your parents used to give you on weekends so you could go out and have a good time.

Yet others will say “Software development is theory building”. Programs are actually proofs (as in, mathematical proofs). Every commit should tell a story. And solving a customer's problem by FTPing a PHP file is a cardinal sin.

I don't mean to imply there are no developers that simultaneously care deeply about the craft of software development and really empathize with the customer. I do believe they might want to see a professional about a split personality disorder, tho. (post-scriptum edit: this sentence was way overboard; I meant it as tongue-in-cheek “very few people can do that” and I do actually advocate for that in the next section. mea culpa)

What is important?

I do believe that talking to users, understanding their experience, empathizing with them, solving customers' problems and having all the stakeholders on the same page is critical to the success of a software project.

I also believe that creating good code is a craft that requires skill, patience, attention to detail, experience and wisdom, and that it will continue to be relevant in the times ahead.

¿Por qué no los dos?

To the extent that we can pull it off, I think we should aim for both. A deep understanding of the system we're building, together with a deep understanding of why we're building it.

Loudly proclaiming that “code is easy” or, at the opposite end, “code is art, a creative human expression that cannot be automated”, is just burying our heads in the sand.

It's cope. And you don't want cope, you want to thrive.

By this, I don't mean “jump on the LLM bandwagon.” I don't mean “become a manager of fleets of AI agents.” I also don't mean “AI-generated code is stolen slop garbage, fight it with tooth and nail, the bubble will pop soon enough anyways.”

But do recognize we're in the middle of an industry-wide tectonic change. We need to figure out how to adapt. We need to understand what is likely to change and what never changes.

What doesn't change?

Software will be getting more complex. Software will always need maintenance: bit-rot is a fact of life. So is entropy. Technology (hardware and software) will move forward, for better or worse. The tower (skyscraper?) of abstractions grows ever higher.

Users will always want more and be prepared to spend less. They still won't know how to relay their needs and wants. Worse, they still won't know exactly what they want. The disconnect between the customers (who actually pay for the software) and users (who use it) will still be here, as will the tension between the needs of the business and the needs of its customers.

Also: there will never be a shortage of snake oil salesmen. Tech du jour comes and goes (I'm still waiting for the new VR renaissance!)

What changes?

Programmers have been in the business of disrupting our own industry since the beginning. Nobody uses punch-cards any more. Very few people need to code in assembly, or COBOL. Those decades spent fighting memory bugs in C or C++, with the scars to prove it, are worthless in the age of Rust, Go, Python and JavaScript.

I'm old enough to appreciate valgrind or remember mysql_real_escape_string() from the PHP4 era—stuff I'll never again need in my life. And that wasn't even so long ago! I narrowly missed the dBase, Clipper, HyperCard and Access era, technologies which I can still spot operating in shops, cafes, or a dusty, once beige and now golden-brown, midi-tower still happily running some bespoke biz solution (backups? what backups?)

How do we thrive?

Accept that change happens. Be equal parts curious and critical about the new stuff.

Understand there's a lot of hype and try to discriminate between hot air and what really works (and to what extent). Also be aware of ever-shifting goalposts: stand back and look at the past year, or five, and assess the velocity of change (technical, economic, societal).

Your role and your responsibilities will be changing. Be willing to invest time and energy into better understanding fields or roles adjacent to yours.

If you're a senior developer, don't just find solace in deepening your expertise. Learn about user experience, customer interviews, or business strategies for the companies in your domain. It will help you gain a better appreciation of all the work done to put a piece of software into users' hands, whether or not you'll actually ever have to do any of those other bits.

If you're just starting or are junior in your role: invest in deepening your understanding of how software works. Understanding pointers, recursion, or memory hierarchy will help you even if you're a JavaScript developer. Understanding network protocols and how HTTP works will be useful even if you're building WordPress plugins. Do leetcode and learn about algorithms and data structures even if you don't need to. Don't be afraid to ask why and how exactly.

For inspiration, here are a few books and other resources that might be helpful:

One more thing

Whoever you are, don't outsource your understanding, judgement, empathy and taste to AI. Don't abdicate your responsibility. Don't be a meat proxy.


PS. Lots of interesting and insightful comments over at Hacker News and Lobsters—the post really hit a nerve. Fascinating how many different experiences people have and the varying definitions of coding, programming, development and engineering they use.

Over the past week I've played around with Kimi K3 by Moonshot AI and Qwen 3.8 Max by Alibaba.

Both are large Chinese open-weight models (weights promised to be released soon) and tout benchmarks showing they're as capable as the frontier western models (Fable 5 by Anthropic and GPT-5.5 Sol by OpenAI).

I wouldn't go that far, but these are really capable models. In my AI-coding tests, both have performed really well. Compare the test mini-games on my vibe-coding benchmark generated by Fable, Sol, K3 and Qwen.

In a more serious test, building a web app to a provided spec, K3, Qwen and Fable generated very similar results. An AI judge (GPT-5.5 Sol via Codex) gave a positive code review to all three (of course, it did find some problems and room for improvement), with Fable being slightly better.

“Good enough” is great!

What I am most excited about, though, is that the open-weights models have reached the threshold of “good enough” for serious AI-assisted engineering. The Anthropic and OpenAI models reached this around October-November last year, and it unleashed a huge adoption wave across the software development industry.

But there was always a possibility of a rug-pull: either through intelligence (tokens) becoming too expensive (and not included via standard subscriptions), models being explicitly withheld (as with the Fable fiasco) or nerfed (Fable and Sol, with their overly aggressive allowed-usage filters).

Open models are insurance against this. Although these models are too large to be reasonably hosted locally, there's already a cottage industry of third-party inference providers. And for organizations that really need to keep all their data close, there exists an (expensive) option of hosting it themselves.

The Chinese scare

There's much angst in the West about these models being Chinese. As such, they might reflect a kind of world-view that's not completely compatible with traditional western values. There's also a question of breaking western labs' terms of service and copying from them.

Both Anthropic and OpenAI, having scraped the entire public internet and trained on copyrighted material such as books, don't get to complain. My personal view is that training on copyrighted material is fair use, but you don't then get to disallow training on your API results.

The censorship and model alignment that follows the ideas of the Chinese government is real (though let's not downplay the alignment done by western labs for different topics). But with these models being open, the censorship layer can relatively easily be stripped away by post-training.

Western open models

The Chinese models (Kimi, Qwen, DeepSeek, GLM) are the most prominent, but they don't have a monopoly on open models: one of the most popular small models is Google DeepMind's Gemma.

Then there are models like Laguna S2.1, Nemotron 3 and Mistral Small 4 and many more, which usually don't make a big splash but are nevertheless very capable.

Taken together, there is a healthy ecosystem of open LLMs of various sizes (from 4B to 3T params). Most of them are open-weights (meaning you only get the weights), but some are fully open source (you get the training data as well).

As these models reach the point of “good enough” in their niches or for specific use cases (like AI coding I started this post with), they are already solid alternatives to the big popular models.

Hardware

The one big difference between open-weights models and free software, in terms of user experience, is which hardware you need. Today (mid-2026), the average hobbyist has no way of running the large models in any usable way.

Computers like Mac Studio, NVidia DGX Spark or the AMD Strix Halo, with unified memory, cost on the order of $5000 and can only run models up to 100B-200B params. Kimi K3 is 2.8T and Qwen 3.8 Max is 2.6T!

I'm optimistic, though. There's so much money sloshing around AI-capable hardware (NVidia has a $5T market cap and 85% profit margins, high-bandwidth memory (HBM) makers are also rolling in money) that I have no doubt there's going to be increased competition, increased performance, and reduced pricing in a few years' time (it takes time to build fabs, sorry).

I'm a desktop Linux user — specifically Debian GNU/Linux with GNOME and Wayland. I also do a fair number of video calls involving screen sharing. And I have an ultra-wide screen monitor (32:9).

This can sometimes be a challenging combination. I want to share a portion of my screen and any window shown there, but most of the software I use only supports sharing either a single window, or an entire monitor.

If I share a single window, it's annoying to share a different window every time I need to show something else. If I share the entire monitor, the aspect ratio means the other participants will have a pretty bad time watching it.

Year of screen sharing on the Linux Desktop

Wayland has been around for almost 20 years, but the support in the wider ecosystem is still spotty. One reason is enhanced security (or — introducing any security at all) compared to the old X11 protocol, which breaks some use cases, screen sharing being one of them.

The Wayland way to do screen sharing is through PipeWire and XDG Desktop Portal. In a nutshell, the application that wants access to the screen asks the environment, which checks with the user (through a modal dialog) and then allows limited access.

The access can be to a single window, a region of the desktop, or a monitor — but most of the apps only support single window or entire monitor share. Not sure why: perhaps the region share is a relatively new addition most apps haven't picked up yet.

In any case, it's pretty annoying, and searching on the internet didn't yield any easy workaround. So I built one.

Waymirror

My workaround was to build a small app that uses the same components to get access to a selected region, then simply show that in a window. Other apps can then screen-share that window.

The app is called Waymirror and is available from PyPI and GitHub. If you want to try it out, note it depends on a number of GNOME and FreeDesktop system dependencies.

Assuming you have the dependencies, the usage is:

pip install waymirror

waymirror left # mirror the left half of the current monitor
waymirror right # mirror the right half of the current monitor
waymirror # select a region to share
waymirror 640x480+100+100 # define the region as X geometry

Recap of my short posts on LinkedIn in May

Unlimited Power, Limited Focus

In the age of AI, focus is essential.

We now have, to quote Darth Sidious, unlimited power (subsidized by Anthropic and OpenAI). But we don't have unlimited focus.

In fact, many of us behave like squirrels on caffeine. We can run very fast, burning the midnight candle at both ends, wasting our time and tokens on stuff that, had we paused to think about it, would not pass muster.

Code is a liability — always has been. We're now printing the liability with such abandon that Leeroy Jenkins would look sheepish in comparison.

With everyone having this awesome tool at their disposal, how can you stand out?

  1. Use your judgement, wisdom, and taste.
  2. Focus. Keep your eyes on the ball.
  3. Understand that AI is a good servant, but a bad master.

And FFS, don't brag about burning tokens. Brag about what you've achieved with the tokens.

AI Is Technology, Not a Feature

If you run, or work for, a tech startup, you've seen this: customers, investors, and bosses ask you “do you have AI yet?”. There's a lot of unhealthy pressure to keep up with the competition and ship “AI features”.

AI is great technology, but it's not “a feature”. In fact, the best implementations out there are where you wouldn't even notice it (if it weren't so prominently showcased).

The fact of (startup) life is, you're pressured into both adopting and marketing your use of AI. It's on you to find the good use cases that fit nicely into your product.

I explore the conundrum in AI is technology, not a feature.

Code Review is Broken

In The agent principal-agent problem, David (cofounder of Tailscale, founder of Exe) raises an uncomfortable question: do we need code reviews?

This echoes Ankit's (founder of Aviator) How to kill the Code Review and Justin's (cofounder of StrongDM) Software Factories essays. In particular, Justin argues that “Code must not be written by humans” and “Code must not be reviewed by humans.”

I also touched on this in my Code reviews in the age of AI article a few months ago, where I argue we should put more emphasis on reviewing the plans/specs, and only do limited, targeted manual code reviews.

If you're leading a software engineering team and don't want to sacrifice quality for velocity, this question is worth thinking about, and discussing with your team.

Style Convergence in AI-generated Design

The curious case of the “contemporary Fraunces serif magazine editorial” design in Claude.

Here's what happened to me yesterday (all in one day):

I had to quickly whip up a website, and I turned to Lovable for some inspiration. The design looked nice but too close to FT/WSJ and even had some undertones of Anthropic.

So I fired up Claude Design and asked it to do the same (based on the same brief containing no design guidelines). The results looked eerily similar.

I fired up Claude Code (CLI). Same thing. I was sure I'd somehow triggered this with my website brief, even without actually specifying it.

Then I noticed a LinkedIn post from someone featuring a virtually identical design. Now I was sure it wasn't my prompting or something contaminating my agents' contexts.

This looked like a new version of the “Bootstrap design” effect, where AI agents mostly churn out similar pages. I told Claude to go in a completely different direction, and called it a day... or so I thought.

Because hours later, I saw the same damn design on Twitter, from none other than Peter Steinberger, author of OpenClaw, talking about vibe-slopped web pages.

To top it all off, in the evening I was helping my kid with some physics lessons and decided to create an interactive visualiser in Claude Web, to help with the understanding behind the math. Guess what: same friggin' design!

Now, I understand LLMs are not creative. But I also understand they are supposed to be non-deterministic, and this was pretty damn deterministic in my book!

I suspect the culprit is the combination of how Claude was trained, and Anthropic's “frontend-design” skill, which probably got loaded into all of those places. Lovable doesn't disclose which LLMs they use (to the best of my knowledge), but this would pretty strongly indicate Claude, and with the frontend skill enabled. As for why Claude prefers this: since it is similar to what Anthropic itself uses, I suspect there was some (unintentional?) stylistic or taste influence (leakage?) from their designers into the training data.

Whatever the cause may be, somehow, Claude overwhelmingly tends to converge on this type of design.

I mean, it's a nice design — it was nice once. Now I'm seeing it everywhere; it's like the em dash all over again.

Bun, Ported from Zig to Rust by AI

This is cool and scary: Bun, a JavaScript platform (alternative to NodeJS), has been (officially) ported from Zig to Rust using AI.

We've seen LLM-powered rewrites (chardet, justhtml) before. This is different because of scale. Bun is a large and much more complex project than either of those, and it was apparently ported in two weeks.

Projects at this scale (like Claude's Compiler or Cursor's browser) have so far been interesting experiments, but a far cry from production-ready code.

The merged PR has a million lines of new code, which presumably haven't been human-reviewed. A week ago the author claimed 99.8% of all tests passed (on Linux). Looks like it took them only a week to get to 100% across all supported platforms.

More quietly, a similar rewrite has been happening at Ladybird, a new browser with its own from-scratch engine (i.e. not just a wrapper for Chrome, Firefox, or another existing browser). It was originally written in C++, and they've started (slowly) porting it to Rust with AI's help — not automatically.

A few thoughts:

  • first public, successful large-scale project using fully autonomous, non-reviewed AI — we'll probably see more
  • robust test suites are a must — this would be a non-starter otherwise
  • Rust, and to a lesser extent Go, are becoming the go-to languages for AI-assisted rewrites
  • this would have been at least a year-long project without AI

Happy First Birthday, Cijene API

This post is in Croatian

🎂 Sretan rođendan, Cijene API! 🎂

Prije točno godinu dana stupila je na snagu Odluka o objavi cjenika, čime je Vlada RH obvezala velike trgovačke lance da dopuste automatsko preuzimanje (scraping) i obradu cijena.

Vidjevši tu objavu, pokrenuo sam Cijene API kao zabavan vikend projekt.

Godinu dana kasnije, podržavamo 29 trgovačkih lanaca, preko tisuću poslovnica, prikupljamo preko 10 milijuna cijena dnevno, a u ovih godinu dana prikupili smo ukupno preko 3 milijarde cijena.

Sve ovo javno je dostupno kroz naš API na cijene.dev i kroz dnevne arhive cijena.

Imamo nekoliko desetaka API korisnika (komercijalnih i nekomercijalnih), projekt pokriva svoje troškove servera, a imamo i malu, ali aktivnu zajednicu ljudi koji doprinose, što prijavom problema, što kodiranjem — hvala im od srca!

Posao nije gotov. Dok ovo tipkam imam jedan PR u pripremi za promjenu CSV formata jednog lanca i drugi PR za dodavanje još izvora. Serveri trgovačkih lanaca ponekad se ruše ili kasne s objavama. Naš API bi mogao biti još bolji.

Ali kroz ovu prvu godinu, mogu reći da su (posredno) stotine tisuća građana Hrvatske vidjele ili iskoristile informacije koje su prošle (na ovaj ili onaj način) kroz Cijene API.

Idemo dalje!

Running a Frontier LLM on Your Own Hardware

The shape of things to come: how to run a frontier-level LLM on consumer hardware. Salvatore Sanfilippo (a.k.a. Antirez, best known as the author of Redis) has been working on a new LLM inference engine (like llama.cpp, VLLM, or HF transformers), optimized for the DeepSeek V4-Flash model.

The DeepSeek V4-Flash is a smaller version of DS' newest model, released a few months ago, with 284B params, of which 13B are active, supporting a 1M context window.

What Antirez is doing with his project (dubbed DwarfStar 4) is to really push the hardware to its full extent, hyper-optimized for the model in question, whereas other engines are more generic and thus can't make tradeoffs to speed up one LLM version.

DwarfStar 4 (DS4) supports Metal (Apple) and CUDA (NVIDIA) architectures, with ROCm (AMD) on the way. But it also runs on CPU, if you're really patient.

The other piece of the puzzle is the hybrid 2-bit quantization for the model, i.e. using only ~2 bits for each floating-point parameter (down from the original 16). If you know how floating point works, this feat alone is mind-boggling, but it works, with noticeable but acceptable quality tradeoffs.

The end effect is that you can run DS4 on a machine with 96+ GB of VRAM, like the NVIDIA DGX Spark, or 96+ GB of unified RAM (like the Macs). Or, if you're really patient and only do it for testing — on ANY machine with 128GB of RAM.

Well, I'm patient and only do it for testing, and I happen to have 128GB of RAM, so I took it for a spin. Well, at ~1 token/s, “rotating slowly” would be a more apt term :) It's supposed to run at quite usable 20-30 t/s on Macs or Sparks.

It did a great Minesweeper (no surprise there), and a working RTS! Don't get me wrong, it was barely working and full of glitches. Much worse than the DeepSeek-V4 Pro version tested via the official API.

But — it's fully local. And it does work.

Now the only thing we need is a bit faster (and cheaper) hardware. Let's go, Moore, we're counting on you!

The Frog Has Already Been Boiled

People on LinkedIn, X, Facebook and Instagram are worried about the upcoming Google search UI change, removing the links to content sites. I'm here to tell you not to worry — the frog has already been thoroughly boiled.

For years, Google has been a steadfast partner for many — or most — commerce sites on the internet. Through SEO juice, paid ads, or actual word of mouth (remember that, anyone?), Google sent traffic to sites. Users were happy, sites were happy, Google was happy. Now that Google has a competent AI and all the data it can ask for, it doesn't need to link to sites so much.

AI is just the tip of the iceberg, but Google has been experimenting with this for years. Yet, like addicts, sites needed the juice fix, and did everything Google asked of them in the guise of “best practices”.

Now the other shoe dropped, chickens are coming home to roost, and the frog is cooked.

It gets better: LinkedIn, X, Facebook, etc. — all the places people use to voice this — are doing the same. Y'all are feeding LinkedIn with data (ironically, this post as well), and it's staying locked within its walled garden. One example: LinkedIn has recently stopped allowing non-authenticated browsers to even expand the links in posts (meaning I can't open a link in a private/incognito window, which annoys me to no end).

On X, you can't open a thread / see replies to a post unless you're logged in. Combined with pushing users to add links to outside pages in comments, you get a lock-in mechanism.

On Facebook and Instagram, you often can't see the post unless you're either on the app or logged in. I purposely do neither, and have no end of traffic lights, fire hydrants and bicycles to click through if I really want to see a shared post.

There's going to be a feast, and your content is on the menu.

Bon appétit!

There's a lot of psychosis around AI. My belief is that as a technology, it can both be used in a way that improves the lives of people, and leveraged in a way that will harm us.

Like in the parable of two wolves, the one that wins is the one we feed. So how do we feed “good AI”?

Here's how I, personally, want to use it:

As a tool. It's here to help me, not to steal my attention or get fed by me (I have a cat for that). I want to be the active operator, not merely a clueless user or an unsuspecting audience.

To grow. As a research tool, an infinitely patient tutor who, true, might occasionally be wrong. Not as a crutch to avoid thinking.

To remove the grind. Some hard things are worth doing. Some are not. Sometimes the grind is just tedious and doesn't help us grow. Washing machines, dishwashers, and now AI (when used wisely) can free up time and energy for better things.

To stop and smell the roses. Productivity is output over time. I want the AI productivity boost to give me more time, not just more output. If AI can 10x me, a 10-hour workweek and 250% productivity increase sound vastly more preferable to 10x output.

To care about the details. More time to dedicate to the small details that usually fall below the quality fold. I want to delight and be delighted and be proud of the result. I want to use AI for anti-slop!

For silly things. Like memes, slop can be fun. Low production effort doesn't mean low creativity. Not everything in life must be serious, high-brow and a result of man's struggle.

As a power tool. Forklifts, power tools, and other machines help us shape our world way beyond our physical capability. Calculators, computers and calendars do the same for our mental capabilities.

I recognize that using AI as a power tool to remove the grind can easily transform into using it as a crutch. Here's what I keep in mind to avoid falling into that trap:

Focus. AI makes everything deceptively simple, so it's tempting to do everything. That's just wasting time.

Judgement. AI is a really fancy autocomplete tool. I still want to be in control of thinking, guiding and judging its efforts. AI can give me options, but I get to pick and choose.

Taste. I'm definitely not an artist, but as a human being I claim to have at least a spark of creativity and taste in me. For whatever it's worth, it makes all the difference between something human-made and autogenerated slop.

Intuition. I subscribe to the notion that human intuition is a superb pattern matching machine trained over our lifetime and, in work context, career. Like in the corny Star Wars line, I do want to listen to my feelings.

You may say I'm a dreamer, but it works for me. I do hope I'm not the only one. Care to join me?