pllu.net

MIT Sloan and Stanford researchers had 1,000 adults ask chatbots for financial guidance, then simulated lifetimes of following it. The advice was better than the researchers expected: higher savings, diversification, sensible risk reduction with age. The catch is that outcomes tracked prompt quality. Women and less financially literate users ended up roughly $50,000 worse off by 60, and people unfamiliar with AI nearly $100,000 worse, because their prompts drew weaker advice. The models also leaned on rules of thumb, failing to adjust to shocks like unemployment.

Good advice being freely available but unevenly extractable is a striking new kind of inequality.

Allen Holub: if you really want to treat AI-generated code as a black box, your tests have to be immaculate and extensive, and he lists what that actually means, starting with all functionality and running through a long tail most suites never reach. “‘It works’ is not sufficient.”

The fine print on Uncle Bob’s gauntlet: not reading the code is only as safe as the test suite is complete, and software factories fail on exactly the qualities tests don’t price in.

Sean Goedecke argues that fully understanding your codebase is a small-team luxury. In large systems nobody understands it all, and effective engineers work from partly correct theories, making educated guesses and dealing with the consequences. He frames “pure” engineering (small codebases, complete understanding) and “impure” engineering (large systems, partial models) as different professional cultures, and treats understanding as one value to trade off among many, like performance or compliance.

A useful counterweight to cognitive debt: if full cognitive coverage was never on offer at scale, agents are not taking away something we actually had. Uncle Bob’s gauntlet of constraints is one way of living with that.

Manifest ran an LLM router for four months, classifying requests into complexity tiers and routing them across providers to cut costs, then killed it. A prompt alone does not reveal how hard a task is, prompt caching (cache reads 75 to 90 per cent cheaper) undercuts the savings, and switching models mid-workflow hurts consistency. Their conclusion: a good router stays sticky to one model, doing its job “by, ironically, not doing it”.

The HN discussion broadly agrees that frontier models are now interchangeably good for everyday work, and that nobody has time to learn each model’s quirks when a new one lands every week. The consistency point rhymes with cognitive coverage: switching tools constantly means never really knowing them.

Y Combinator’s software team has open-sourced qm, an agent platform for a whole company rather than one person, living in Slack and on the web. A headless TypeScript core with Postgres handles identity, dual-scoped memory and permissions (personal workspaces plus shared team projects), sandboxed tool execution, and crons for background automation. The harness itself is pluggable: Claude Code, Codex, OpenCode or Pi. MIT-licensed and designed to be forked privately rather than consumed as a product.

A production-scale data point for the ideas in anatomy of an agent harness and harness engineering.

“Your AI writes like a LinkedIn post. Make it write like a Boeing manual.” SimpleEnglish is a skill that forces LLM documentation into ASD-STE100, the controlled language aerospace has used since 1983 so a tired mechanic cannot misread an instruction: measured 72.9 per cent fewer violations across six Claude models, with AI slop dying as a side effect. The underlying observation (via @geogristle) is that controlled languages built for human safety turn out to be exactly the constraint that stops models writing filler.

In the HN discussion, several people want it for their own emails and Slack messages, one shows an output that is still wordier than real STE, and another notes drily that this is the third ASD-STE100 submission in a fortnight: this week’s trend, though maybe a good one.

Uncle Bob Martin (coding since the late 60s) no longer reads the code his agents write. Instead he surrounds them with extreme constraints, from unit and gherkin tests to mutation testing, and trusts code that has “run the gauntlet of all of my constraints and tests”.

The polar opposite of cognitive coverage: commit at zero understanding and bet the harness makes up for it. Harness engineering and Jason Swett’s TDD skill, taken to the logical end.

Jina Yoon’s framework: autonomy should depend on the task, not the model. “Trusting your agents just because the models got smarter is like skipping your seatbelt because you got a nicer car.” Two questions decide it: is the work easy to check, and are mistakes cheap to undo? That yields four levels, from assistant mode (hard to check, costly to undo) up to self-driving (easy to check, cheap to undo, like dependency updates), with PostHog examples of moving work up the ladder.

The checkability axis is doing the same work as the constraint-building in constrain the agent.

PostgreSQL internals visualised as a working 3D city: watch queries move through the engine like traffic. An independent educational prototype, openly flagged as early and reviewed, with a correction template for anyone who spots an inaccuracy. A playful companion to the Postgres survival guide.

The HN discussion is mostly delight (“I don’t know what I am looking at but it is fabulous”) plus useful feedback that the guided tour is too busy and should be interactive, and the tantalising idea of generating visualisations like this for whatever you’re currently learning.

A preliminary study finding that older people who avoided food in the four hours before bed did better on problem-solving tests, suggesting time-restricted eating may slow cognitive decline. Early-stage research rather than settled science, but a cheap intervention worth keeping an eye on.

Gergely Orosz “cannot help but see the concept of code reviews fading away”. A rock-solid, very experienced engineer he spoke to reviewed all their AI-generated code until Fable, then concluded the review was pointless and stopped, except for key parts. One anecdote, but from a careful observer of engineering practice, and consistent with where Uncle Bob and antirez already landed. The open question is what replaces review as the quality gate; Graphite is betting it doesn’t need replacing.

Anthropic removed over 80 per cent of Claude Code’s system prompt for the Claude 5 generation with no performance loss, and this post generalises the lessons: rules give way to judgment, worked examples give way to well-designed tool interfaces, everything-upfront gives way to progressive disclosure, and manual memory management gives way to auto-memory. For your own setup: keep CLAUDE.md thin and focused on genuine gotchas, prefer pointing at code (specs, test suites) over describing it, and let skills guide rather than constrain.

Practical vindication of the map-not-manual approach this repo’s AGENTS.md already takes.

Kenton Varda: building software by prompting agents without ever reading or editing the code “isn’t actually a new thing. It’s just called being an engineering manager”, a different skill with decades of accumulated practice behind it. The analogy is genuinely useful, but it has a gap worth holding onto: a human team carries far more durable memory and shared context between tasks than an agent team does, so the management playbook doesn’t transfer cleanly.

Dex of HumanLayer argues the lights-off software factory fails for a structural reason: RL training for coding models has no fast, reliable oracle for maintainability. “There is no penalty for eroding codebase maintainability”, only pass/fail on immediate tests, and design damage that compounds over months can’t be backpropagated. Harness engineering fixes the speed problem, not the quality problem. His answer: front-load alignment (product review, architecture, program design before coding), build in vertical slices, and keep humans reviewing inside constrained workflows: 2 to 3 times faster safely rather than 10 to 100 times faster into chaos.

A structural argument for why the dark factory level stays out of reach, and grist against Uncle Bob’s gauntlet: tests can’t price in design erosion.

The HN discussion ranges from “one of the best writeups of how RL shapes model behaviour” to accusations that software factories are Rube Goldberg machines and their proponents self-appointed experts, via the honest observation that human PR review was never that great to begin with.

Alexander Belanger of Hatchet distils Postgres operations into tiers: schema design, indexing and short transactions first; then understanding the query planner (EXPLAIN ANALYZE, accepting that seq scans sometimes make sense) and tuning autovacuum before bloat accumulates; then the sharp tools like FOR UPDATE SKIP LOCKED queues, partitioning, and trigger-based migrations. The framing that sticks: “queries either seq scan or they don’t”, so optimisation is more binary than it feels.

The HN discussion mostly adds what the guide leaves out: monitoring and alerting for the few fatal failure modes, and a backup and restore plan, which several commenters reckoned is the real first item on any survival guide.

A design tool from a former Figma engineer that uses diffusion models as the design engine for agents: generate and iterate on UI designs, turn them into working products, and build reusable brand systems. Interesting as a bet that agents need a visual design medium of their own rather than driving human design tools.

Mozilla’s assessment of the open-model ecosystem: the gap to closed frontier models is down to about 4 points on the Artificial Analysis index, open weights now route the majority of OpenRouter tokens, Chinese models carry 46 per cent of routed tokens against 36 for the US, and inference prices have fallen roughly 50-fold in three years. One theme is that value is accruing above the model, in orchestration, tools, memory and permissions. As one HN commenter put it: “the harness is what takes these random and hallucinogenic models and makes them into something deterministic and useful”.

Pairs with harness engineering on the value-above-the-model theme, and with America’s open-model paradox on how it got this way.

The HN discussion spent as much energy on the report’s scroll-animated presentation as on its substance (“Open ships easy. Open deploys hard.”), but the sharper thread speculates that open weights eventually undercut the frontier labs’ economics entirely: hyperscalers run them without licensing fees while the labs carry the training costs.

Boris Cherny (creator of Claude Code) hears the same thing everywhere: one person is 10x-ing their output with Claude and the rest of the org hasn’t caught up. He maps adoption as four steps, and the key observation is that tokens alone never move you forward: each step needs the next set of bottlenecks broken and the next set of guardrails built. In practice that means giving Claude ways to verify its own work end to end, auto permissions, automated code and security review, and interfaces for managing multiple agents. On measuring return, prefer the counterfactual to usage dashboards: would you have spent the engineering hours anyway, and what would they have cost?

Dean Meyer and Konstantine Buhler on distillation asymmetry. Qwen’s share of new open-model fine-tunes rose from 1 per cent in January 2024 to 69 per cent by February 2026, and Western labs now legally use Chinese open weights as teachers (Thinking Machines bootstrapped Inkling’s fine-tuning with synthetic data from Kimi K2.5) while equivalent use of GPT or Claude outputs is prohibited by their terms. The flow runs: Western frontier models → alleged unauthorised extraction → Chinese open weights → lawful Western post-training. Every Western frontier advance creates another teacher for Chinese labs, but not for Western ones.

Tariq’s formula for the ideal prompting technique: thin prompts, thick artifacts and context, thin skills. Nine words that compress a lot of hard-won practice: put the effort into durable context the agent can read (specs, tests, docs), not into elaborate per-task prompts or over-prescriptive skills.