Alexander Kaluzhny

Software developer focused on web applications. Python, Django, React.js

[Sam Altman @sama]

one of the quotes i find most inspiring on a hard day:

"Whatever your hand finds to do, do it with all your might, for in the realm of the dead, where you are going, there is neither working nor planning nor knowledge nor wisdom"

Ecclesiastes 9:10

[Armin Ronacher ⇌ @mitsuhiko]

Periodic reminder that Russia is still shelling Ukrainian civilians. https://t.co/qfsCl1iGN1

[Uncle Bob Martin @unclebobmartin]

Morning Bathrobe Rant: AI out-codes you; deal with it.

[Alexander Kaluzhny @AlexanderKaluz]

This is a must-read. thanks @badlogicgames
https://t.co/h3avmfjPnl

[kitze · supermac.io 🐦‍🔥 @thekitze]

plan mode

[Alexander Kaluzhny @AlexanderKaluz]

https://t.co/ECOtG9q1Om

[Alexander Kaluzhny @AlexanderKaluz]

https://t.co/QXQUmwfmuc

[Ray Dalio @RayDalio]

https://t.co/tjmbT5ytUN

[@levelsio @levelsio]

how to build a bootstrapped startup without funding:

1. pick a problem you personally have. if you don't use your own product daily, quit now

2. skip the pitch deck. open your code editor. ship something ugly in a weekend

3. charge money from day 1. free users give you nothing but support tickets

4. use boring tech. PHP, SQLite, vanilla JS. frameworks are a trap that mass waste your time

5. host on cheap VPS ($5-20/mo). not AWS. you don't need kubernetes for 1,000 users

6. do customer support yourself. it's the fastest product feedback loop that exists

7. automate everything you do more than twice. cron jobs > employees.

8. grow on Twitter/X by building in public. your journey IS the marketing

9. keep your burn rate near zero so you never need to raise. ramen profitable > series A

10. say no to investors, cofounders, and "advisors" who want equity for intros

i've been doing this for 10+ years now. no employees, no funding, no board meetings

the entire VC game is designed to make you think you need permission to start

you don't

[Andrej Karpathy @karpathy]

A lot of people quote tweeted this as 1 year anniversary of vibe coding. Some retrospective -

I've had a Twitter account for 17 years now (omg) and I still can't predict my tweet engagement basically at all. This was a shower of thoughts throwaway tweet that I just fired off without thinking but somehow it minted a fitting name at the right moment for something that a lot of people were feeling at the same time, so here we are: vibe coding is now mentioned on my Wikipedia as a major memetic "contribution" and even its article is longer. lol

The one thing I'd add is that at the time, LLM capability was low enough that you'd mostly use vibe coding for fun throwaway projects, demos and explorations. It was good fun and it almost worked. Today (1 year later), programming via LLM agents is increasingly becoming a default workflow for professionals, except with more oversight and scrutiny. The goal is to claim the leverage from the use of agents but without any compromise on the quality of the software. Many people have tried to come up with a better name for this to differentiate it from vibe coding, personally my current favorite "agentic engineering":

- "agentic" because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight.
- "engineering" to emphasize that there is an art & science and expertise to it. It's something you can learn and become better at, with its own depth of a different kind.

In 2026, we're likely to see continued improvements on both the model layer and the new agent layer. I feel excited about the product of the two and another year of progress.

[Alexander Kaluzhny @AlexanderKaluz]

@mitsuhiko Armin, thank you for continuing to care and for keeping attention on Russia's terror in Ukraine.

[Armin Ronacher ⇌ @mitsuhiko]

Periodic reminder that Russia is still attacking civilians in Ukraine. A country mostly without power at this point, in freezing cold conditions. https://t.co/FqUOv5ET5q

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

[Armin Ronacher ⇌ @mitsuhiko]

Ukraine now has not a single power plant that was not hit by missiles, most of them not operational right now. Kyiv currently is -13 °C. People are freezing for days, pipes are bursting. And we got so used to the news of the war, that it's not even a front page story any more.

[Reads with Ravi @readswithravi]

This video by Scott Adams will rewire your brain to never feel lazy again. Excellent insight.

[Alexander Kaluzhny @AlexanderKaluz]

This post deserves to be learned by heart.
https://t.co/CHAOtkTQb5

[Andrej Karpathy @karpathy]

I've never felt this much behind as a programmer. The profession is being dramatically refactored as the bits contributed by the programmer are increasingly sparse and between. I have a sense that I could be 10X more powerful if I just properly string together what has become available over the last ~year and a failure to claim the boost feels decidedly like skill issue. There's a new programmable layer of abstraction to master (in addition to the usual layers below) involving agents, subagents, their prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP, LSP, slash commands, workflows, IDE integrations, and a need to build an all-encompassing mental model for strengths and pitfalls of fundamentally stochastic, fallible, unintelligible and changing entities suddenly intermingled with what used to be good old fashioned engineering. Clearly some powerful alien tool was handed around except it comes with no manual and everyone has to figure out how to hold it and operate it, while the resulting magnitude 9 earthquake is rocking the profession. Roll up your sleeves to not fall behind.

[Alexander Kaluzhny @AlexanderKaluz]

With coding agents there is now more work than before - there's simply more things worth building. And it's become much more interesting. For me, agents shaved off the tedious manual stuff, opening the way to tackle bigger business problems that now feel like low-hanging fruit.

[Alexander Kaluzhny @AlexanderKaluz]

Jevons paradox is really noticeable now.
https://t.co/2roZ9oh9iJ

[keshav @keshavchan]

karpathy on how to learn and become an expert