Matěj Bránský

Happily married. 👫 JS/TS developer. ⚛

[Gergely Orosz @GergelyOrosz]

So, at your company, what are you doing about the spiking token prices?

Approaches I hear:

1. Inference routing - route more basic workloads to a LOT cheaper APIs or providers

2. Use cheaper open models for inference (eg Fireworks, Baseten etc)

3. Default model: cheap one

[dax @thdxr]

us: we are struggling to figure out the best way to use coding agents, we don't have clarity yet

everyone else: our team is moving at speeds unheard of, all our PRs are ai generated, we've cleared 6 years of backlog

man we must really suck huh

[DHH @dhh]

Microservices is the software industry’s most successful confidence scam. It convinces small teams that they are “thinking big” while systematically destroying their ability to move at all. It flatters ambition by weaponizing insecurity: if you’re not running a constellation of services, are you even a real company? Never mind that this architecture was invented to cope with organizational dysfunction at planetary scale. Now it’s being prescribed to teams that still share a Slack channel and a lunch table.

Small teams run on shared context. That is their superpower. Everyone can reason end-to-end. Everyone can change anything. Microservices vaporize that advantage on contact. They replace shared understanding with distributed ignorance. No one owns the whole anymore. Everyone owns a shard. The system becomes something that merely happens to the team, rather than something the team actively understands. This isn’t sophistication. It’s abdication.

Then comes the operational farce. Each service demands its own pipeline, secrets, alerts, metrics, dashboards, permissions, backups, and rituals of appeasement. You don’t “deploy” anymore—you synchronize a fleet. One bug now requires a multi-service autopsy. A feature release becomes a coordination exercise across artificial borders you invented for no reason. You didn’t simplify your system. You shattered it and called the debris “architecture.”

Microservices also lock incompetence in amber. You are forced to define APIs before you understand your own business. Guesses become contracts. Bad ideas become permanent dependencies. Every early mistake metastasizes through the network. In a monolith, wrong thinking is corrected with a refactor. In microservices, wrong thinking becomes infrastructure. You don’t just regret it—you host it, version it, and monitor it.

The claim that monoliths don’t scale is one of the dumbest lies in modern engineering folklore. What doesn’t scale is chaos. What doesn’t scale is process cosplay. What doesn’t scale is pretending you’re Netflix while shipping a glorified CRUD app. Monoliths scale just fine when teams have discipline, tests, and restraint. But restraint isn’t fashionable, and boring doesn’t make conference talks.

Microservices for small teams is not a technical mistake—it is a philosophical failure. It announces, loudly, that the team does not trust itself to understand its own system. It replaces accountability with protocol and momentum with middleware. You don’t get “future proofing.” You get permanent drag. And by the time you finally earn the scale that might justify this circus, your speed, your clarity, and your product instincts will already be gone.

[render @infinterenders]

react fiber is honestly one of those things that people think they get until they actually look under the hood and then suddenly the whole thing feels like some alien technology living inside javascript. everyone parrots those same shallow lines like “fiber is the new diffing engine” or “fiber is concurrent rendering” and it’s just… no man, it’s so much deeper and way more deranged than that. the old react, the stack one, was like this innocent recursive tree walker that just kept diving into components like some happy kid climbing down a ladder, except that ladder was welded directly to the javascript engine’s callstack, so once you’re halfway down you can’t stop, you can’t turn around, you can’t take a break, you can’t do shit except finish it. so if you had big trees, like some giant UI with thousands of nodes, react would just lock the entire main thread and choke the browser until it was done. you typed into an input? too bad, the browser can’t react because react is too busy react-ing. it was legit painful. and the browser’s like “pls, bro, i need to paint” and react’s like “nah bro, i’m in the middle of rendering this dumb component”.

so the react team basically looked at that mess around 2016 and realized the entire approach was screwed. like no amount of small optimizations could fix the fact that recursion is not interruptible in JS. the JS engine owns the stack, not you. and if you can’t pause, you can’t avoid jank, it’s just physics. so instead of fighting it, react just said screw the whole model and built their own stack. not metaphorically, literally. that’s what fiber is. it’s not some “algo”, it’s an entire fake callstack implemented as a linked structure of nodes. each fiber is like a tiny memory cell react controls completely, storing the component type, props, state, the children pointer, sibling pointer, parent pointer, priority info, effects flags, and all this other internal stuff. it’s like react turned every component into a little OS task.

and the crazy part is that because it’s all controlled manually, react finally got freedom from the JS callstack. instead of recursive rendering, it’s this iterative stepping through fibers one by one. and that suddenly means react can pause. like just literally stop mid render, drop everything, let the browser repaint, handle input, chill, take a breath, then pick up exactly where it left off inside that huge UI tree. no more “oh no i’m stuck deep in recursion”. you can’t get stuck because react isn’t using the builtin stack anymore. it’s rolling its own.

this is where the whole scheduling thing comes from. people think scheduling is some abstract idea but it’s literally react walking the fiber graph and deciding which updates matter more. typing is urgent. animations are medium. background data fetching is low. old react treated everything the same and that's why old apps felt like garbage when doing heavy work. fiber changed that whole world. suddenly react could say “yo, someone typed into an input, drop the low-priority render, resume later.” and the app stays smooth even if you have 50k components.

and because fiber creates this double-tree thing, the current tree and the work-in-progress tree, react can run through the whole render phase in like a simulation mode. this is the wild part most ppl dont realize: when react is “rendering”, it’s not touching the dom at all. it's building this offscreen imaginary version of what the UI should look like. and only when the whole thing is done, consistent, no half-finished nodes, react switches to the commit phase and actually mutates the real DOM. like how game engines draw everything in a hidden buffer then flip it. that’s why the UI never shows broken half-updated states. fiber gives react the room to compute the perfect frame before actually showing it.

and dude, this is exactly why suspense works. why transitions feel smooth. why server components can be streamed in and stitched into the client ig

[Tanner Linsley @tannerlinsley]

I'll continue to die on the hill of "magic directives are bad API interfaces". They're not type-safe, they're not extensible, no native runtime control, they're just strings.

... I can't believe I'm saying this, but I would rather debate @ directives. Pls rewind history.

[dax @thdxr]

karpathy on using LLMs for coding
exactly how i use them, interactively in way where i also learn
and this is why we focus so much on speed

[Mikuláš Minář @mikulasminar_]

Ivan a Josef Trojanovi naprosto lidsky a jednoduše. ❤️

Podepište výzvu https://t.co/SGRlQbewtG, pojďte volit a pošlete tento vzkaz dál. ✌️

[Ara @arafatkatze]

In building AI agents @cline , we've identified three mind viruses Mind Viruses are seductive ideas that sound smart, but don’t work in practice.
1. Multi-Agent Orchestration
2. RAG (Retrieval Augmented Generation)
3. More Instructions = Better Results
Let's explore why!

[dax @thdxr]

we are officially working on opentui - a library for building terminal UIs in typescript

it is built on the work of kmdrfx - we are sponsoring him to solve this problem once and for all

clip is not sped up and it's running entirely in the terminal - link to repo in reply

[Darja Stomatova @darja_stomatova]

🇨🇿🇺🇦Marshallův plán pro Ukrajinu českého prezidenta Petra Pavla. Dárcovský summit v Římě. Tady je všech 11 bodů:

1. rozšíření “koalice ochotných” o další členy

2. efektivní řízení rekonstrukce skrze rozhodovací orgán zakotvený v platformě dárců Ukrajině

3. vytvoření jednotné digitální platformy pro sledování, řízení a sladění společného úsilí o rekonstrukci

4. mobilizace soukromého kapitálu skrze zvýhodněné nástroje jako jsou nízkoúročené úvěry nebo záruky pro projekty

5. nasazení veřejných zdrojů včetně společných dluhopisů EU a ruských státních aktiv k nastartování investic a budování důvěry

6. včasná integrace Ukrajiny do jednotného trhu EU, která by měla podpořit hospodářský růst země a posílit její evropskou trajektorii

7. zvyšování institucionální a technické kapacity Ukrajiny s cílem zefektivnit plánování, řízení a implementování rekonstrukce

8. posilování ukrajinského lidského kapitálu prostřednictvím vzdělávání, školení a akademických aktivit

9. investiční aktéři by měli přispívat tam, kde to bude mít největší smysl, tj. bez vázání na regionální mandát (Česko se tak nadále bude zaměřovat na zdravotnictví a prohloubí své zapojení do oblasti energetiky, dopravy, vodohospodářství a městské infrastruktury)

10. ukrajinské vedení musí odpovědně zajistit transparentnost, efektivitu a inkluzívní dohled

11. do rekonstrukce musí být zahrnuta geografická vyváženost, tj. pomáhat nejen v bezpečnějších lokalitách ale i v oblastech u frontové linie

FOTO: březen 2025

[Matěj Bránský @matej_bransky]

@badlogicgames Thanks for sharing! May I ask what speech-to-text tool you’re using?

[Brendan Falk @BrendanFalk]

We are pivoting away from doing enterprise AI transformations ("AI-native Palantir"). For now at least.

I've shared our key learnings below. I'll share a detailed blog post soon.

What's next? We are going to start moving insanely quickly on several other ideas. Stay tuned 😎

[Luke Wroblewski @LukeW]

everybody’s building the same thing.

[Matěj Bránský @matej_bransky]

A reflection of solo building and launching Clipio. The good, the bad, and lessons learned from @pustelto. https://t.co/0N3F6J3QOM

[vas @vasuman]

Claude 4 just refactored my entire codebase in one call.

25 tool invocations. 3,000+ new lines. 12 brand new files.

It modularized everything. Broke up monoliths. Cleaned up spaghetti.

None of it worked.
But boy was it beautiful.

[Patroni Česka (Perun s námi) @FundPerun]

TEMNÉ ČASY NAD EVROPOU: MAĎARSKÁ ZRADA
1/10) Píše se 1. únor roku 2022 a Viktor Orbán za zavřenými dveřmi rokuje s Vladimírem Putinem.
O pár dní později se dává do pohybu maďarská armáda, připravuje stavbu pontonových mostů.

Tohle není alternativní příběh, to je zdokumentovaná historie. Pod pokličkou je toho ale mnohem, mnohem víc. ⬇️

[Aaron Boodman @aboodman]

Here is a screenshot of a modern productivity app.

Look at this UI and try to enumerate all the potential interactions that are visible. I can see maybe 100 accessible within one click.

And multiples more within a few clicks.

Every. Single. One. of these needs to respond instantly, before the network responds. Each one needs to handle server errors and rollback if the server write fails. Each one needs to support concurrent edits on multiple devices, with conflict resolution. Each one needs to implement permissions. And every one needs to update any dependent UI reactively.

Using traditional data access libraries, doing this properly for *just one control* is days of work. This is why most web applications do not have Notion's level* of responsiveness. It's too much effort!

* And yes, I know, even Notion leaves something to be desired in terms of responsiveness! But building even Notion level of UI is well, well beyond the capabilities of traditional data access approaches.

To build a complex UI where every interaction point responds instantly, you need to abstract up a level. You can't be dealing with individual requests. That is like building a UI by turning individual pixels on and off.

You need a way to declaratively say "This is the data I most commonly need for this UI. Please get it to the device and keep it up to date".

You need a way to say "The user went to a new place, please also keep this new set of data available locally".

And finally, you need a way to modify the local data, with the UI updating instantly and the change propagating behind the scenes.

This is what sync engines are. Declarative network access. A higher level of abstraction for building complex, interactive, high-performance user interfaces.

[Matěj Bránský @matej_bransky]

@DuffieldJesse I have no problem with that. Thanks for the explanation!

[dax @thdxr]

i landed on a somewhat disturbing vision for how LLMs + coding might play out

the past week i've been using opencode as much as possible to stress test before its launch - think there's a cursed set of properties here that hasn't been seen much with other tech

i've talked before about how the key thing with vibe coding is that it is low exertion - asking an LLM to build something allows you to turn your brain off while it executes

it's often slower, it often does it wrong, it costs literal money - but it lets you be lazy

even if it takes 30 minutes and 5 prompts to do a task that should take 10min of focus for a human - you get to spend 25 of those minutes with your brain idling

we were talking about this as a team and everyone had an unflattering example of kicking some work to the LLM so they could watch youtube - it's less efficient but it feels better

we of course had cases where it let us parallelize work but these lazy scenarios are undeniably a real thing - they are replacing moments where you'd be in flow state

LLMs seem to have a weird combination of properties - they are

- less efficient
- lower quality
- allows you to be lazier

any tech with the last bullet point always wins - it's impossible to fight but it's usually paired with efficiency or quality

but in this case it looks more like a future where everyone is mindlessly prompting so they can spend more time scrolling tiktok

the output will be worse and everything will take longer and we lose all the second order benefits of doing focused work