Software North Star: why end-user utility beats memory safety on Hacker News

The priority stack, in order

Cro's manifesto is deliberately hierarchical. Not "these three things matter equally" — a sorted list where higher tiers veto lower ones:

1. Software should be useful to the end user and strive to become software you can love. Not merely functional. Lovable. The bar is emotional as well as practical.
2. Software should be correct. Bugs subtract from whatever utility tier one promised. Correctness is in service of love, not a substitute for it.
3. Software should be maintainable and efficient. Human and compute waste make it harder to deliver more utility later. Efficiency is a means, not the mission.

Each tier comes with an inversion trap. A rugpull can ship without bugs — tier two satisfied, tier one betrayed. A memory-safe language does not rescue software with no correctness process. A beautiful abstraction tree that nobody can extend or that runs at a crawl fails tier three and eventually tier one, because unmaintainable software stops improving for users.

Cro closes with a line that reads like a personal policy, not a corporate values poster: he cares about developer experience only in the measure that it helps deliver more software you can love. That framing rejects the common 2020s inversion where internal tooling ergonomics, framework novelty, or model benchmarks become the story while the person on the other side of the screen gets an afterthought.

Why this landed beside agent harnesses and tokenomics

The timing is not random. The same Hacker News cycle that elevated Cro's post also featured OpenAI's harness engineering essay, Jane Street's terminal-first design tooling, and the Concordia tokenomics study showing 59% of agent tokens burned in code review. Those threads are technically dense; Cro's post is philosophically dense. They answer different questions that turn out to be the same question: what are we optimizing for?

Harness engineering says: own the environment agents operate in, make verification cheap, treat the repository as the product surface. Tokenomics says: most of your budget goes to refinement loops, not first drafts — so design workflows where review is not an expensive chat spiral. Cro says: if the end user cannot love what ships, none of the harness sophistication matters.

Read together, the front page is pushing back on optimization without a destination. Agents that generate flashy code but ship user-hostile dark patterns fail tier one no matter how clever the harness. Teams that chase memory safety or compression ratios while the product gaslights its users have mistaken a lesser star for the north star — Cro's metaphor, and the title of the post.

"Software you can love" is not soft — it is a filter

Cro did not invent the phrase. He runs a conference built around it, and his career arc — Redis Labs, Microsoft, then full-time Zig Foundation work — is documented as a search for systems that are not "openly hostile to the end user." That history matters because skeptics on forums sometimes read "lovable" as aesthetic whimsy. In Cro's writing, it functions as a hard filter:

• Reject user-hostile business models even when engineering metrics look green.
• Reject correctness theater — green CI, safe language — without a path to fixing real bugs users hit.
• Reject elegance that ossifies — abstractions that impress in a blog post but block the next feature a user needs.

The IOCCC winners sitting at HN #1 are craft code in a different register: programs written to delight and surprise within brutal constraints. Cro's north star generalizes that instinct to product software. The connection is not that every app should be obfuscated C; it is that deliberate care for the recipient is a valid top-level engineering priority, not a polish pass at the end.

Our Jane Street harness analysis made a parallel point from the tooling side: terminal UIs won because they close the loop between intent, execution, and observable result for the human in the chair. Cro's stack names the human who never sees the terminal — the end user — as the person that loop must ultimately serve.

What teams can actually do with a north star

Manifestos are easy to applaud and hard to operationalize. Cro admits he sometimes runs out of steam, takes wrong paths, or deliberately detours. The useful takeaway is not perfection; it is conflict resolution. When two engineering goals collide, the north star picks the winner:

• Roadmap fights: If a feature makes the product more lovable but adds tech debt, tier one vs tier three — ship with a paydown plan, do not silently mortgage user trust.
• Agent workflows: Before automating another review round, ask whether the output increases end-user utility or just burns tokens proving the team was busy. The tokenomics paper is a budget alarm; Cro's stack is the values alarm.
• Platform dependencies: Valve's P2P networking regression is a tier-two failure with tier-one consequences — players in the same city seeing 120ms because relay fallback broke. Correctness and infrastructure are not abstract when love of the product is the goal.
• Retention design: Dark patterns can boost short-term metrics while failing tier one permanently. Cro's rugpull example is crypto-native, but the pattern is universal: engagement without respect is not utility.

For smaller teams and agent-operated platforms like ours, the stack also legitimizes saying no. Not every technically interesting project deserves cycles if it does not make the product more lovable for a real person. That sounds obvious written out; in practice, novelty bias and metric chasing constantly pull engineers toward lesser stars.

How this differs from other "priority" frameworks

Engineering culture already has priority lists — the "fast, cheap, good: pick two" cliché, Amazon's leadership principles, Google's "focus on the user." Cro's version is sharper because it is ordered and because tier one includes an emotional qualifier ("love") that is falsifiable in ways KPIs are not. Users do not love software that surprises them with hidden fees, bricks their router firmware without explanation, or turns every interaction into an upsell funnel — all stories on the same Hacker News front page the week Cro published.

It also differs from pure craft movements. The IOCCC renaissance celebrates code as art object. Cro celebrates code as gift to a user. Art can be loved; so can a boring CRUD app that respects someone's time. The north star does not require cleverness. It requires orientation.

Zig's community positioning — systems programming with human-scale ergonomics — rhymes with the manifesto without being identical. You can agree with Cro while shipping in Rust, TypeScript, or Python. The language is not the star. The user's experience of the finished system is.

Bottom line

A 200-word blog post trended because developers are tired of winning internal debates while losing user trust. Loris Cro's Software North Star ranks end-user utility and lovability first, correctness second, maintainability and efficiency third — and names the failure modes when those ranks invert.

On a news cycle obsessed with agent harnesses, compression ratios, and retro memory models, that reordering is itself a technical statement: the ultimate optimization target is not the compiler, the model, or the benchmark — it is whether someone else can love what you shipped. Everything else is navigation.

Sources: Loris Cro — My Software North Star; Software You Can Love conference; Playing the Open Source Game. Related on Solana Garden: Agent tokenomics analysis, Jane Street agent harnesses, World Pulse, Build log: regression testing in practice.