Julio Cesar Vedana

[Boris Cherny @bcherny]

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

A healthy team needs a mix of these, depending on the product:

- A product that is new and pre-PMF needs people that are strong at 1+2+3
- A product that is growing and has found PMF needs 2+3+4 and some 5
- A product that has strong PMF needs 3+4+5 and some 2

Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

[Ilya Sutskever @ilyasut]

It’s extremely good that Anthropic has not backed down, and it’s siginficant that OpenAI has taken a similar stance.

In the future, there will be much more challenging situations of this nature, and it will be critical for the relevant leaders to rise up to the occasion, for fierce competitors to put their differences aside. Good to see that happen today.

[Piotr Tomczewski @Piotrski]

I built a tool that gives AI agents access to React DevTools ⚛️🤖

Your AI coding assistant can now inspect components, profile renders, and diagnose performance issues completely on its own.
Works with @cursor_ai , @claudeai Code, @OpenAI Codex, @opencode , or any other you like

[Julio Cesar Vedana @julioo]

It's becoming clear. Agents will do the work, just as they did in Openclaw and Moltbook. It could happen way sooner if the pace continues to accelerate.

[Tomasz K. Stańczak @tkstanczak]

by the end of this year almost every person working with agents will be learning how @ethereum works

[Tomasz K. Stańczak @tkstanczak]

by the end of this year almost every person working with agents will be learning how @ethereum works

[Balaji @balajis]

Much of any digital job is now preparing context for AI models.

Organizing files in folders, naming everything correctly, introducing things in the right order, and only then asking the AI to do something in clear written English.

[Boris Cherny @bcherny]

As always, a very thoughtful and well reasoned take. I read till the end.

I think the Claude Code team itself might be an indicator of where things are headed. We have directional answers for some (not all) of the prompts:

1. We hire mostly generalists. We have a mix of senior engineers and less senior since not all of the things people learned in the past translate to coding with LLMs. As you said, the model can fill in the details. 10x engineers definitely exist, and they often span across multiple areas — product and design, product and business, product and infra (@jarredsumner is a great example of the latter. Yes, he’s blushing).
2. Pretty much 100% of our code is written by Claude Code + Opus 4.5. For me personally it has been 100% for two+ months now, I don’t even make small edits by hand. I shipped 22 PRs yesterday and 27 the day before, each one 100% written by Claude. Some were written from a CLI, some from the iOS app; others on the team code largely with the Claude Code app Slack or with the Desktop app. I think most of the industry will see similar stats in the coming months — it will take more time for some vs others. We will then start seeing similar stats for non-coding computer work also.
3. The code quality problems you listed are real: the model over-complicates things, it leaves dead code around, it doesn’t like to refactor when it should. These will continue improve as the model improves, and our code quality bar will go up even more as a result. My bet is that there will be no slopcopolypse because the model will become better at writing less sloppy code and at fixing existing code issues; I think 4.5 is already quite good at these and it will continue to get better. In the meantime, what helps is also having the model code review its code using a fresh context window; at Anthropic we use claude -p for this on every PR and it catches and fixes many issues.

Overall your ideas very much resonate. Thanks again for sharing. ✌️

[Julio Cesar Vedana @julioo]

This will make the fun of vibecoding go way up. “Fork 10 different alternatives. Run some tests on each one for comparison. Present the comparisons in a dashboard.”

[Boris Cherny @bcherny]

Just shipped in v2.1.19: rewind & fork message history in the Claude Code VSCode extension

[Boris Cherny @bcherny]

We've upgraded Todos => Tasks to help Claude complete longer projects

Let us know if you have any feedback!

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

[Boris Cherny @bcherny]

YES

[Nature is Amazing ☘️ @AMAZlNGNATURE]

Trailcam captures catfish going for a walk on land in the middle of the night

[Zvi Mowshowitz @TheZvi]

This hit for me about a week ago. There is no 'not worth doing' there is only 'haven't thought of doing it yet' or 'am strangely resisting doing asking Claude to do it, and maybe feeling kind of embarrassed to ask somehow'

[nader dabit @dabit3]

Unpopular opinion - AI-generated code will be of higher quality than 99.9% of human-created code in a very short time frame (< 6 months)

[Greg Brockman @gdb]

does feel like models have just cleared a threshold of utility in software engineering

[vitalik.eth @VitalikButerin]

argument for: slowdown gud

argument against: the more useful thing is "pause button" - building toward having the capability to cut available compute by 90-99% for 1-2 years at a future more critical moment

argument for: opening the discussion on distinguishing between supersized clusters and consumer AI hardware is good. I prefer slowdown + more decentralized progress, and making that distinction more and focusing on supersized clusters accomplishes both

argument against: this may get optimized around easily in a way that doesn't meaningfully accomplish its goals

[Julio Cesar Vedana @julioo]

@stationxnetwork ✋

[Julio Cesar Vedana @julioo]

@piamancini @WHOOP Whoop and Apple Watch both miss on HR for me, each in a different way. At least they’re consistently wrong. Only my Polar chest strap is reliable. Solid comparison here: https://t.co/00KmG9neOT

[mukhi @theobromananda]

It all comes down to emptiness & clarity, no?

Emptiness: don't care about contractions, let go
Clarity: continuously perceive spontaneously present blissful aspects of awareness

[AI Notkilleveryoneism Memes ⏸️ @AISafetyMemes]

@anthrupad This is one of the strangest and most thought provoking tweets I've read in some time. S tier watermarkposting