Sebastian Andil

Software Engineer specializing in Web Applications development

[Sebastian Andil @selrond]

The only thing I truly miss in @CastroPodcasts is a full-text queue search.
Seems like such a low-hanging fruit

[Addy Osmani @addyosmani]

https://t.co/jKCIAEzai7

[Sebastian Andil @selrond]

Haven’t been this eccited about a piece of software for a loong time!

[Mikkel Malmberg @mikker]

I've built an entirely new, 100% native, extendable, themeable, modal cmd-space launcher for macOS.

🍣 Meet Tuna.

https://t.co/9mFeIcBoUS

[Gary Bernhardt @garybernhardt]

Today is our quarterly reminder that Linus gave us a completely distributed VCS, so we stored all of our repos in a single point of failure.

[Sebastian Andil @selrond]

@FabianHiller https://t.co/t3oiT2k2Xs

[Sebastian Andil @selrond]

The first point
> RHF types and schemas are separate.
is practically not true if you’re using schema validation library.

Using @hookform/resolvers the types are inferred from the resolver automatically (with few exceptions).

[Sebastian Andil @selrond]

The first point
> RHF types and schemas are separate.
is practically not true if you’re using schema validation library.

Using @hookform/resolvers the types are inferred from the resolver automatically (with few exceptions).

[Fabian Hiller @FabianHiller]

React Hook Form, TanStack Form, or Formisch — which one should you actually pick in 2026? 🧐

We compared all three across TypeScript inference, validation architecture, and performance as forms grow. ⚡️

No API walkthroughs. Just the tradeoffs that matter for real decisions. Give it a read!

https://t.co/dBBBYxViNv

[trish @TrisH0x2A]

wise words from the best systems engineer I've worked with:

"two things that make code actually maintainable:

1. reduce the layers a reader has to trace
2. reduce the state a reader has to hold in their head"

applies to every codebase. always.

[Richard Feldman @rtfeldman]

In the past 3 years, I haven't noticed any uptick in release speed for software I use. If productivity is increasing, I can't tell as an end user.

I have noticed decreases in uptime, increases in bugs, and a HUGE increase in people bragging about how many PRs per day they land.

[Tom Goodwin @tomfgoodwin]

When are tech folk going to get that people like wasting time, it's life. They don't optimize for efficiency, they try to get by, they watch dumb stuff, they enjoy shopping. Inefficiency is another work for living and life.

Your m mean and median job isn't a software engineer in Menlo Park, it's Ashley in accounts in a not for profit in Columbus, it's Jesse , the office manager for a tool rental business in Tallahassee, they are more likely to use a Fax machine than Slack.

They quite like meetings because they like chatting, they'll use AI to make a better invite to their baby shower, not agentify their job.

These people, nor their bosses boss, aren't in a rush to build software as a side hustle, they are keen to use AI to check if their vet is overcharging them. They'd like AI to check spelling on the email to the school governor.

They don't want agentic commerce, they want AI to be in the background and make living a little less stressful

[Rhys @RhysSullivan]

it's funny how a model that's great at thinking and backend is a terrible frontend just like real engineers

[Uncle Bob Martin @unclebobmartin]

I do not feel like I'm not programming. In fact, I feel like I am programming more intensely than ever. I'm just not coding.

[Addy Osmani @addyosmani]

Every abstraction shift in software history made devs more productive by raising the level of intent.

This is the next step: from writing code to orchestrating systems that write code (building "the factory" for your code).

The unsolved problem isn't generation but verification. That's where engineering judgment becomes your highest-leverage skill.

To truly scale, think "factory model" - orchestrate fleets of agents like a production line: clear specs as blueprints, TDD for quality control, strong architecture to amplify leverage.

[Seb ⚛️ ThisWeekInReact.com @sebastienlorber]

By the way, TypeScript is finally strict by default 🎉

[Ryo Lu @ryolu_]

software is still about thinking

software has always been about taking ambiguous human needs and crystallizing them into precise, interlocking systems. the craft is in the breakdown: which abstractions to create, where boundaries should live, how pieces communicate.

coding with ai today creates a new trap: the illusion of speed without structure. you can generate code fast, but without clear system architecture – the real boundaries, the actual invariants, the core abstractions – you end up with a pile that works until it doesn't. it's slop because there's no coherent mental model underneath.

ai doesn't replace systems thinking – it amplifies the cost of not doing it. if you don't know what you want structurally, ai fills gaps with whatever pattern it's seen most. you get generic solutions to specific problems. coupled code where you needed clean boundaries. three different ways of doing the same thing because you never specified the one way.

as Cursor handles longer tasks, the gap between "vaguely right direction" and "precisely understood system" compounds exponentially. when agents execute 100 steps instead of 10, your role becomes more important, not less.

the skill shifts from "writing every line" to "holding the system in your head and communicating its essence":

- define boundaries – what are the core abstractions? what should this component know? where does state live?
- specify invariants – what must always be true? what are the constants and defaults that make the system work?
- guide decomposition – how should this break down? what's the natural structure? what's stable vs likely to change?
- maintain coherence – as ai generates more code, you ensure it fits the mental model, follows patterns, respects boundaries.

this is what great architects and designers do: they don't write every line, but they hold the system design and guide toward coherence. agents are just very fast, very literal team members.

the danger is skipping the thinking because ai makes it feel optional. people prompt their way into codebases they don't understand. can't debug because they never designed it. can't extend because there's no structure, just accumulated features.

people who think deeply about systems can now move 100x faster. you spend time on the hard problem – understanding what you're building and why – and ai handles mechanical translation. you're not bogged down in syntax, so you stay in the architectural layer longer.

the future isn't "ai replaces programmers" or "everyone can code now." it's "people who think clearly about systems build incredibly fast, and people who don't generate slop at scale."

the skill becomes: holding complexity, breaking it down cleanly, communicating structure precisely. less syntax, more systems. less implementation, more architecture. less writing code, more designing coherence.

humans are great at seeing patterns, understanding tradeoffs, making judgment calls about how things should fit together.

ai can't save you from unclear thinking – it just makes unclear thinking run faster.

[Sebastian Andil @selrond]

https://t.co/BkDFHAbBwb

[Sebastian Andil @selrond]

This is such an interesting phenomenon:

Agent skills change the knowledge landscape.

What was once fragmented across blogs, GitHub issues, Reddit posts, and Twitter threads is now available as thousands of neatly packaged pieces of markdown.

[Ben Holmes @BHolmesDev]

skills_sh is such a useful tool. Helped me discover that @addyosmani is already ramping out agent skills for common web development audits like SEO and HTML accessibility. Kudos 🙌

[Tony Alicea @AnthonyPAlicea]

No release of any new LLM model will change the fact that you need to understand what you're doing as a developer.

[Andrej Karpathy @karpathy]

A few random notes from claude coding quite a bit last few weeks.

Coding workflow. Given the latest lift in LLM coding capability, like many others I rapidly went from about 80% manual+autocomplete coding and 20% agents in November to 80% agent coding and 20% edits+touchups in December. i.e. I really am mostly programming in English now, a bit sheepishly telling the LLM what code to write... in words. It hurts the ego a bit but the power to operate over software in large "code actions" is just too net useful, especially once you adapt to it, configure it, learn to use it, and wrap your head around what it can and cannot do. This is easily the biggest change to my basic coding workflow in ~2 decades of programming and it happened over the course of a few weeks. I'd expect something similar to be happening to well into double digit percent of engineers out there, while the awareness of it in the general population feels well into low single digit percent.

IDEs/agent swarms/fallability. Both the "no need for IDE anymore" hype and the "agent swarm" hype is imo too much for right now. The models definitely still make mistakes and if you have any code you actually care about I would watch them like a hawk, in a nice large IDE on the side. The mistakes have changed a lot - they are not simple syntax errors anymore, they are subtle conceptual errors that a slightly sloppy, hasty junior dev might do. The most common category is that the models make wrong assumptions on your behalf and just run along with them without checking. They also don't manage their confusion, they don't seek clarifications, they don't surface inconsistencies, they don't present tradeoffs, they don't push back when they should, and they are still a little too sycophantic. Things get better in plan mode, but there is some need for a lightweight inline plan mode. They also really like to overcomplicate code and APIs, they bloat abstractions, they don't clean up dead code after themselves, etc. They will implement an inefficient, bloated, brittle construction over 1000 lines of code and it's up to you to be like "umm couldn't you just do this instead?" and they will be like "of course!" and immediately cut it down to 100 lines. They still sometimes change/remove comments and code they don't like or don't sufficiently understand as side effects, even if it is orthogonal to the task at hand. All of this happens despite a few simple attempts to fix it via instructions in CLAUDE . md. Despite all these issues, it is still a net huge improvement and it's very difficult to imagine going back to manual coding. TLDR everyone has their developing flow, my current is a small few CC sessions on the left in ghostty windows/tabs and an IDE on the right for viewing the code + manual edits.

Tenacity. It's so interesting to watch an agent relentlessly work at something. They never get tired, they never get demoralized, they just keep going and trying things where a person would have given up long ago to fight another day. It's a "feel the AGI" moment to watch it struggle with something for a long time just to come out victorious 30 minutes later. You realize that stamina is a core bottleneck to work and that with LLMs in hand it has been dramatically increased.

Speedups. It's not clear how to measure the "speedup" of LLM assistance. Certainly I feel net way faster at what I was going to do, but the main effect is that I do a lot more than I was going to do because 1) I can code up all kinds of things that just wouldn't have been worth coding before and 2) I can approach code that I couldn't work on before because of knowledge/skill issue. So certainly it's speedup, but it's possibly a lot more an expansion.

Leverage. LLMs are exceptionally good at looping until they meet specific goals and this is where most of the "feel the AGI" magic is to be found. Don't tell it what to do, give it success criteria and watch it go. Get it to write tests first and then pass them. Put it in the loop with a browser MCP. Write the naive algorithm that is very likely correct first, then ask it to optimize it while preserving correctness. Change your approach from imperative to declarative to get the agents looping longer and gain leverage.

Fun. I didn't anticipate that with agents programming feels *more* fun because a lot of the fill in the blanks drudgery is removed and what remains is the creative part. I also feel less blocked/stuck (which is not fun) and I experience a lot more courage because there's almost always a way to work hand in hand with it to make some positive progress. I have seen the opposite sentiment from other people too; LLM coding will split up engineers based on those who primarily liked coding and those who primarily liked building.

Atrophy. I've already noticed that I am slowly starting to atrophy my ability to write code manually. Generation (writing code) and discrimination (reading code) are different capabilities in the brain. Largely due to all the little mostly syntactic details involved in programming, you can review code just fine even if you struggle to write it.

Slopacolypse. I am bracing for 2026 as the year of the slopacolypse across all of github, substack, arxiv, X/instagram, and generally all digital media. We're also going to see a lot more AI hype productivity theater (is that even possible?), on the side of actual, real improvements.

Questions. A few of the questions on my mind:
- What happens to the "10X engineer" - the ratio of productivity between the mean and the max engineer? It's quite possible that this grows *a lot*.
- Armed with LLMs, do generalists increasingly outperform specialists? LLMs are a lot better at fill in the blanks (the micro) than grand strategy (the macro).
- What does LLM coding feel like in the future? Is it like playing StarCraft? Playing Factorio? Playing music?
- How much of society is bottlenecked by digital knowledge work?

TLDR Where does this leave us? LLM agent capabilities (Claude & Codex especially) have crossed some kind of threshold of coherence around December 2025 and caused a phase shift in software engineering and closely related. The intelligence part suddenly feels quite a bit ahead of all the rest of it - integrations (tools, knowledge), the necessity for new organizational workflows, processes, diffusion more generally. 2026 is going to be a high energy year as the industry metabolizes the new capability.

[Sebastian Andil @selrond]

@devongovett - base Collection feature parity between ListBox, GridList & Tree (sections, autocomplete etc)
- better support for displaying popovers on hover
- allow table row actions in selection mode

[Devon Govett @devongovett]

Introducing the new React Aria docs! 🎉

All-new content and search experience. Interactive CSS and Tailwind examples to get you started quickly – just install with shadcn. New guides and full example apps. MCP server and AI integrations.

Check it out! https://t.co/2LlQw8stZl