reginald curtis

Design Technologist | Design Systems I Married to @jessappeldoorn

[Paul Bakaus @pbakaus]

Impeccable v1.1 is out. Design fluency for every AI harness.

New:
- all commands are now agent skills
- support for Antigravity, VS Code
- simplify -> distill (to not conflict w/ CC's new built-ins)
- universal install

https://t.co/WglrY1uE4B gives you the language to make AI-generated frontends suck less.

[Guillermo Rauch @rauchg]

The future of design is… engineering.

All designers at @vercel now also build, thanks to tools like @v0, Claude Code, and Cursor.

They've been contributing to our frontends and apps for a while now. But over the past few months, the leap they've made is engineering the design process itself by building agents.

A big part of shipping is getting the word out in a compelling way, especially on the @x platform, the everything app.

In the past, we used to spend a bunch of time hand-crafting images and illustrations for social cards.

Our design team built an internal agent and web ui using @v0 and Claude Code that makes this process fully self-serve. It even includes a previewer of what the final artifact will look like on X. It's called Leap.

It's probably saved us hundreds of hours of work but also massively raised our quality bar. The artifacts it produces are beautiful.

If you had asked me even 12 months ago whether our design team would be building their own design tools, let alone be this good, I would call bs. There was no master plan, or God forbid, a "sprint" to make this happen. It just took a handful of prompts to build and it propagated on Slack.

Leap is now one of the many agents that helps us run our company more smoothly, built and securely deployed on @vercel for our internal use.

[𝐑.𝐎.𝐊 👑 @r0ktech]

The longer you spend in tech, the stronger the urge to buy a farm and never touch a computer in your life again.

[Ryan Singer @rjs]

https://t.co/WLFVKseZtZ

[Vercel @vercel]

We just released 𝚛𝚎𝚊𝚌𝚝-𝚋𝚎𝚜𝚝-𝚙𝚛𝚊𝚌𝚝𝚒𝚌𝚎𝚜, a repo for coding agents.

React performance rules and evals to catch regressions, like accidental waterfalls and growing client bundles.

How we collected them and how to install the skill ↓
https://t.co/kfLSbKl15X

[JohnPhamous @JohnPhamous]

help us make it better for you and the web

https://t.co/cefkPwppM7

thanks to @argyleink, @wwwjim, @destroytoday, @lochieaxon, @pacocoursey, @joebell_ & @austin_malerba for their contributions

[Ibelick @Ibelick]

Agents are getting better at creating UI, but some things still annoy me.

I wrote them down as https://t.co/mPQ27gNa3Z.

https://t.co/QeJjCaCRgd

[Brian Lovin @brian_lovin]

Well you see it's simple really it's all about context management and making sure the models get the right context at the right time so rules are like always-on context but commands are like on demand context that the user invokes which are different than skills which are like rules but with little descriptions so the model uses them dynamically to save space in the main thread and then subagents boy howdy those guys are all about keeping the main context clean and parallelizing work so you see it's simple if you really just think about the context

[Ridd 🤿 @ridd_design]

I'm totally rethinking how I prototype with AI after seeing how Atlassian's design system team does it

their approach to "templates" and "recipes" in Figma Make is pretty genius 👇

[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.

[Addy Osmani @addyosmani]

My LLM coding workflow going into 2026: https://t.co/4OPPRxrniN. Specs, skills, MCPs, small iterative chunks, and always review what the AI suggests.

[Emil Kowalski @emilkowalski]

I don't share this one often, but https://t.co/wAwQUrPVNz is a project I made last year. It contains a bunch of interviews with designers and engineers from companies like Vercel and Linear. Thought you might find it interesting!

[luis. @disco_lu]

The design system to do list widget is now live!

It's a tool to help check off component requirements before it gets to production: states, accessibility, documentation, tokens

The goal is to bridge design and dev, increasing confidence in production

https://t.co/uuuKTE1nld

[jhey ʕ•ᴥ•ʔ @jh3yy]

here's the @CodePen for this one 👨‍🍳 — works in all browsers 🤙

(where interpolate-size isn't supported, do a frame measure on load ✅)

https://t.co/rJC2mH0vji

[jhey ʕ•ᴥ•ʔ @jh3yy]

accordion transitions w/ css ::details-content, <details> + <summary> 🧑‍🍳

details:has(~ [open]) { --y: -1; }
[open] ~ details { --y: 1; }
details { translate: 0 calc(var(--y) * 1rem); }
[open]::details-content { height: fit-content; }

[Meng To @MengTo]

I made a 31-min tutorial on prompting with GPT-5.1 to create amazing UIs.

Insane how fast it is now.

[Devon Govett @devongovett]

Having a blast re-designing all the React Aria examples this week. Flat design is so over – bring back depth! 😃

[Vlad Moroz @vladmoroz]

Introducing Paper Mono: a beautiful monospace font for design and code.

Get the download and more details in the thread.

[Una 🇺🇦 @Una]

🥳 CSS functions have arrived!!! 🥳

And they are *AWESOME*

Now, you can do things like this:

@​function --alpha(--color, --opacity) {
result: rgb(from var(--color) r g b / var(--opacity));
}

div {
background: --alpha(red, 80%);
}

(*arrived = in the latest stable Chrome)

[Lenny Rachitsky @lennysan]

Less than a month ago I published part 1 of my essential reading series, and it’s already my 9th most popular post of all time. There’s a growing need for curated, thoughtful content as an antidote to the endless slop filling our feeds and inboxes.

To continue building the highest-signal-to-noise library for product builders, I’ve picked 10 additional timeless reads that you probably haven’t read but should. The pieces below cover a wide spectrum of advice around growth, leadership, communication, entrepreneurship, and more.

I’m not including books here—that list is yet to come. If you have suggestions for essays I’m still sleeping on, please share them in the comments.

List below 👇