Rewriting React , the end of software engineering , HTML vs

The TLDR Dev digest from May 11 is the strongest case yet that the tools we use to build the web are being quietly rewritten from the kernel up.

What You Need to Know: Tanner Linsley rebuilt the React API from scratch for TanStack Start, producing a ~9KB gzip runtime (vs. React's ~60KB) that runs 2–3x faster while passing all tests and powering two production sites. Sean Goedecke argues software engineering "may no longer be a lifetime career" because AI coding tools reduce the manual learning that builds deep expertise. And a popular post argues HTML is a better file format than Markdown for AI agents — richer, interactive, and more information-dense, at the cost of higher generation time and token spend.

Why It Matters

• TanStack's React rebuild is a proof that "the framework you ship" is no longer "the framework you import." Code regeneration at build time lets a project ship only the parts of React it actually uses. The 9KB number isn't a benchmark flex — it's a sign that dependency management is going to look more like Linux distribution package selection than npm install.
• The "end of software engineering as a career" thesis is real, but the argument is more subtle than the headlines. Goedecke's piece isn't "AI replaces programmers" — it's "AI makes the skill curve so steep that early-career engineers never build the foundation that makes them effective seniors." The market will reward the top decile more than ever. The bottom 80% is going to feel like contract work.
• HTML vs Markdown for AI agents isn't a style preference — it's an information-density trade-off. Markdown is faster to generate and cheaper to tokenize. HTML carries more structure, more interactivity, and more visual fidelity. The right answer for agents is "use whichever fits the task," but most teams are defaulting to Markdown because that's what the agent demos look like.
• For builders: the architectural questions of 2026 are not "which framework." They are "which parts of which framework do we actually need, and can we ship only those?"

What Actually Happened

Projecting React: a 9KB rebuild

Tanner Linsley published "Projecting React," a long-form essay on rebuilding the React API from scratch for TanStack Start. The result: a ~9KB gzip runtime, compared to React's ~60KB, running 2–3x faster while passing all tests. Two production sites are already running on the projection. The technique: cheap code regeneration at build time, so a project ships only the React features it actually uses. The implication Linsley draws: general-purpose dependencies as we know them are obsolete. The future of web development will look like Linux distributions — consumers own shape-specific projections of libraries, generated for the workload, not installed as a one-size-fits-all package.

The deeper argument is about the economics of framework adoption. If a rebuild is cheap and the runtime cost of unused features is real, the right move is to ship a custom projection per project. That's the same logic that drove Linux distros to fork the kernel — the upstream is too big and the downstream product needs to be lean.

"Software engineering may no longer be a lifetime career"

Sean Goedecke published an essay arguing that software engineering is structurally shifting from a lifetime career to a high-intensity, limited-duration one. The mechanism: AI coding tools reduce the manual learning required to ship, which means fewer engineers build the deep, internalized expertise that turns seniors into the people who can fix the problems juniors can't see. The immediate productivity gains from AI make adoption mandatory to stay competitive. The long-term cost is skill atrophy in the broader population of engineers. The market still rewards the top decile — but the bottom 80% is going to find that their experience doesn't compound the way it used to.

This is not a "AI replaces programmers" argument. It's a "the on-ramp just got harder, the destination just got more competitive, and the time horizon just got shorter" argument. For anyone in the industry in 2026, the right read is: get dramatically better, dramatically faster, and assume your current skills have a half-life of three years.

HTML vs Markdown for AI agents

A widely-circulated post by trq212 argues that HTML is a better file format than Markdown for AI-generated outputs. The argument: Markdown is a restricted subset of structure that limits how much information an agent can pack into a response. HTML supports richer visualizations, interactive elements, and direct embedding of data — which makes the output more useful for visual code reviews, interactive prototypes, and decision support. The trade-off: HTML is more expensive to generate, slower to render, and costs more tokens. For complex tasks the trade-off is worth it. For trivial summaries, Markdown is still the right default.

The subtext: most agent demos are still Markdown-first because Markdown is cheap and looks good in a chat window. That optimizes for the demo, not for the work. The teams that will win in 2026 are the ones that pick the right format for the task and accept the cost.

Other notable items from the digest

Databricks' Lakebase architecture achieves 5x faster Postgres writes by separating compute and storage, reducing log traffic by 94% and improving read speeds by 50%. The LangChain blog published a useful "anatomy of an agent harness" piece — defining an agent as the combination of a core language model and a surrounding harness that provides code, configuration, and logic for execution. The harness is where the real engineering work lives, and effective harness engineering means managing context rot and building verification loops for long-horizon tasks.

Bun is mid-rewrite from Zig to Rust. 99.8% of the pre-existing test suite passes on Linux x64 glibc after six days of work, on a 960,000-line rewrite. The motivation: memory safety and stability. The progress is a strong signal that the rewrite will land, and that the Rust systems-language ecosystem is mature enough for a production runtime of this size.

The Take

Three stories, one underlying shift: the tools and the careers of web development are being rebuilt around the assumption that you can ship only what you need. TanStack proves you can ship only the parts of React you use. Goedecke's essay argues you can no longer assume the parts of engineering you don't practice will stay sharp on their own. The HTML/Markdown debate argues you can no longer assume the cheapest output format is the right output format. Every "you can no longer assume" in this digest points at the same conclusion: the default settings of the last decade are being revisited in real time.

The TanStack projection is the most actionable item. If you're running a Next.js or Remix app in 2026, the question to ask is: how much of React are you actually using? If the answer is "maybe 30%," there's now a credible path to shipping a runtime that costs you a tenth the bytes and runs 2–3x faster. That's a real P&L line for consumer-facing apps where bundle size is a conversion metric.

The career piece is harder. The honest read is that the on-ramp just got steeper and the time horizon just got shorter. Engineers under 30 should assume they will need to learn in public, ship in public, and re-skill every 24 months. Engineers over 40 should assume their experience is more valuable than ever for the next 3–5 years, and they should be using that window to position themselves as the people who direct the agents, not the people who are replaced by them.

The HTML/Markdown debate is going to be settled by the tools, not by the opinions. The agent frameworks that ship the right format per task will win the teams. The frameworks that force Markdown because the chat UI is Markdown-native will lose them. Expect this to be a real product surface by Q4 2026.

Quick Summary

TanStack rebuilt React as a 9KB projection, running 2–3x faster. Sean Goedecke argues software engineering may no longer be a lifetime career as AI compresses skill curves. A popular post argues HTML beats Markdown for agent outputs when the task is complex enough. Bun is mid-rewrite from Zig to Rust, with 99.8% of tests passing.

Sources

• Projecting React (Tanner Linsley)
• Software engineering may no longer be a lifetime career (Sean Goedecke)
• Using Claude Code: The Unreasonable Effectiveness of HTML (trq212 on X)
• How lakebase architecture delivers 5x faster Postgres writes (Databricks)
• The Anatomy of an Agent Harness (LangChain)
• TLDR Dev 2026-05-11 roundup