Thoai Ngo

Software engineer, SRE. Opinions are my own.

[boris @boristane]

if you're building sub-agents you should stop now

our main agent used to be a workflow with sub-agents, each with a specific role (triaging, investigating, etc.)

we moved to a single agent and latency dropped, quality improved and cost was slashed

https://t.co/2UzloDY5lC

[dex @dexhorthy]

parts I and II have over 700k views together. Now you get to read part III - benchmarking opus 5 on SlopCodeBench https://t.co/QIXjQhhuso

[dex @dexhorthy]

part one of "Why Software Factories Fail" hit 250k views in under 24h - now you get to enjoy part two https://t.co/NLkDvSTDhW

[Viv @Vtrivedy10]

https://t.co/Lb2gtM9SNs

[psmon @webnori]

Running Gemma 4 On-Device in .NET

A Journey of Failure and Success

⸻

🎯 What We Wanted

“On a user’s PC, without internet, without a separate server like Ollama,
we want to directly load Gemma 4 in a .NET app and generate tokens.”

more:

https://t.co/dDwvFFWpC4

[Nicolas Bustamante @nicbstme]

https://t.co/apKknVvir2

[Bilgin Ibryam @bibryam]

Another fantastic guide from Anthropic👇

🌟The Complete Guide to Building Claude Skills🌟
• How to structure your skill folder correctly
• What makes a skill trigger reliably (and what breaks it)
• How to write clear, effective https://t.co/oXwCYNWfC1 instructions
• How to test, iterate, and ship production-ready skills
https://t.co/zWWH2xJVkv

[Dan Hollick @DanHollick]

Did you know that SSDs use quantum tunnelling to store data? Or that we have to completely rewrite RAM every 30ms to prevent data from just dissipating?

If you did, then you can probably skip this chapter on how computers store data:
https://t.co/d7m0TLXAKv

[Tanel Poder 🇺🇦 @TanelPoder]

Discovered an awesome article (and the entire site) via HN.

Example: "How is data stored?"

https://t.co/cCLDov21CD

[Andy Pavlo (@andypavlo.bsky.social) @andy_pavlo]

Here is my latest article on the world of databases: https://t.co/hngkeN0dlN

All the hot topics from the last year:
• More Postgres action!
• MCP for everyone!
• MongoDB gets litigious with FerretDB!
• File formats!
• Market movements!
• The richest person in the world!

[Manthan Gupta @manthanguptaa]

https://t.co/9I1leiSIra

[Addy Osmani @addyosmani]

Every time we've made it easier to write software, we've ended up writing exponentially more of it.

When high-level languages replaced assembly, programmers didn't write less code - they wrote orders of magnitude more, tackling problems that would have been economically impossible before. When frameworks abstracted away the plumbing, we didn't reduce our output - we built more ambitious applications. When cloud platforms eliminated infrastructure management, we didn't scale back - we spun up services for use cases that never would have justified a server room.

@levie recently articulated why this pattern is about to repeat itself at a scale we haven't seen before, using Jevons Paradox as the frame. The argument resonates because it's playing out in real-time in our developer tools. The initial question everyone asks is "will this replace developers?" but just watch what actually happens. Teams that adopt these tools don't always shrink their engineering headcount - they expand their product surface area. The three-person startup that could only maintain one product now maintains four. The enterprise team that could only experiment with two approaches now tries seven.

The constraint being removed isn't competence but it's the activation energy required to start something new. Think about that internal tool you've been putting off because "it would take someone two weeks and we can't spare anyone"? Now it takes three hours. That refactoring you've been deferring because the risk/reward math didn't work? The math just changed.

This matters because software engineers are uniquely positioned to understand what's coming. We've seen this movie before, just in smaller domains. Every abstraction layer - from assembly to C to Python to frameworks to low-code - followed the same pattern. Each one was supposed to mean we'd need fewer developers. Each one instead enabled us to build more software.

Here's the part that deserves more attention imo: the barrier being lowered isn't just about writing code faster. It's about the types of problems that become economically viable to solve with software. Think about all the internal tools that don't exist at your company. Not because no one thought of them, but because the ROI calculation never cleared the bar. The custom dashboard that would make one team 10% more efficient but would take a week to build. The data pipeline that would unlock insights but requires specialized knowledge. The integration that would smooth a workflow but touches three different systems.

These aren't failing the cost-benefit analysis because the benefit is low - they're failing because the cost is high. Lower that cost by "10x", and suddenly you have an explosion of viable projects. This is exactly what's happening with AI-assisted development, and it's going to be more dramatic than previous transitions because we're making previously "impossible" work possible.

The second-order effects get really interesting when you consider that every new tool creates demand for more tools. When we made it easier to build web applications, we didn't just get more web applications - we got an entire ecosystem of monitoring tools, deployment platforms, debugging tools, and testing frameworks. Each of these spawned their own ecosystems. The compounding effect is nonlinear.

Now apply this logic to every domain where we're lowering the barrier to entry. Every new capability unlocked creates demand for supporting capabilities. Every workflow that becomes tractable creates demand for adjacent workflows. The surface area of what's economically viable expands in all directions.

For engineers specifically, this changes the calculus of what we choose to work on. Right now, we're trained to be incredibly selective about what we build because our time is the scarce resource. But when the cost of building drops dramatically, the limiting factor becomes imagination, "taste" and judgment, not implementation capacity. The skill shifts from "what can I build given my constraints?" to "what should we build given that constraints have in some ways been evaporated?"

The meta-point here is that we keep making the same prediction error. Every time we make something more efficient, we predict it will mean less of that thing. But efficiency improvements don't reduce demand - they reveal latent demand that was previously uneconomic to address. Coal. Computing. Cloud infrastructure. And now, knowledge work.

The pattern is so consistent that the burden of proof should shift. Instead of asking "will AI agents reduce the need for human knowledge workers?" we should be asking "what orders of magnitude increase in knowledge work output are we about to see?"

For software engineers it's the same transition we've navigated successfully several times already. The developers who thrived weren't the ones who resisted higher-level abstractions; they were the ones who used those abstractions to build more ambitious systems. The same logic applies now, just at a larger scale.

The real question is whether we're prepared for a world where the bottleneck shifts from "can we build this?" to "should we build this?" That's a fundamentally different problem space, and it requires fundamentally different skills.

We're about to find out what happens when the cost of knowledge work drops by an order of magnitude. History suggests we (perhaps) won't do less work - we'll discover we've been massively under-investing in knowledge work because it was too expensive to do all the things that were actually worth doing.

The paradox isn't that efficiency creates abundance. The paradox is that we keep being surprised by it.

[Ben Dicken @BenjDicken]

Read here:
https://t.co/FUSWSTIe0Z

[Hussein Nasser @hnasr]

Free performance for full table scans in Postgres 17

You see, Postgres like most databases work with fixed size pages. Pretty much everything is in this format, indexes, table data, etc. Those pages are 8K in size, each page will have the rows, or index tuples and a fixed header. The pages are just bytes in files and they are read and cached in the buffer pool.

To read page 0, for example, you would call read on offset 0 for 8192 bytes, To read page 1 that is another read system call from offset 8193 for 8192, page 7 is offset 57,345 for 8192 and so on.

If table is 100 pages stored a file, to do a full table scan, we would be making 100 system calls, each system call had an overhead (I talk about all of that in my OS course).

The enhancement in Postgres 17 is to combine I/Os you can specify how much IO to combine, so technically while possible you can scan that entire table in one system call doesn’t mean its always a good idea of course and Ill talk about that.

This also seems to included a vectorized I/O, with preadv system call which takes an array of offsets and lengths for random reads.

The challenge will become how to not read too much, say I’m doing a seq scan to find something, I read page 0 and found it and quit I don’t need to read any more pages. With this feature I might read 10 pages in one I/O and pull all its content, put in shared buffers only to find my result in the first page (essentially wasting disk bandwidth, memory etc)

It is going to be interesting to balance this out.

Note that true postgres issues a kernel system call to read 8k at a time the kernel can be configured to read “ahead” little bit read more and cache it in the file system cache.

——-
Learn more about database and OS internals, check out my courses
Fundamentals of database engineering https://t.co/tiObG0HPoT
Fundamentals of operating systems https://t.co/WCns5RMqKz

[Hugo @hugorcd]

So, what does the @vercel x @nuxt_js partnership unlock for the community? A LOT.

Get ready for an insane amount of previously "Pro" features, now open-source and free for everyone:

🎁 100+ Nuxt UI Pro components & an extremely comprehensive Figma Kit
🎁 7+ Pro templates (SaaS, Portfolio...)
🎁 A self-hostable, CMS with real-time collaboration (Nuxt Studio)
🎁 A self-hostable admin (NuxtHub) and deeper integrations with Vercel's Marketplace (Postgres, Redis...)
🤖 Deeper AI integration (enhancing v0 Nuxt / Vue capabilities, MCP & more) with Vercel's AI teams

This is a massive win for the entire ecosystem. The future is open 💚

[Thoai Ngo @thoaingo07]

@matteocollina Nodebook

[Enea Jahollari 🅰 @Enea_Jahollari]

I really like reading this article https://t.co/t37VmlSuxo 🙌

[Bilgin Ibryam @bibryam]

"Things we learned about LLMs in 2024"

A great distilation of key themes and pivotal moments from the last 12 months in LLMs
https://t.co/j9BgW9NoQE

[Peter Zaitsev @PeterZaitsev]

Databases in 2024: A Year in Review // Blog // Andy Pavlo - Carnegie Mellon University https://t.co/vOzujlROal

[Peter Zaitsev @PeterZaitsev]

On Long Term Software Development - Bert Hubert's writings https://t.co/IJz4m7s6en