Luke Storry

Software developer, windsurfer and climber.

[Luke Storry @LukeStorry]

so `npx luke` is now a thing

[Steve Yegge @Steve_Yegge]

Something I noticed about working with Fable...

[Ethan Mollick @emollick]

OK, this amused me. I gave Claude a copy of this classic XKCD comic and the prompt: "solve this. do a great job. ask no questions."

And it gave me this in one shot 3 minutes later, including the style (and the note that it thought it was 2024?): https://t.co/srBnHLCIzn

[Addy Osmani @addyosmani]

The future of Software Engineering isn't syntax, but what was always the real work: turning ambiguity into clarity, designing context that makes good outcomes inevitable, and judging what truly matters.

"The entire history of software engineering is one of rising levels of abstraction" - @Grady_Booch

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

[Muratcan Koylan @muratcan]

oh you’re still doing prompt engineering? everyone’s on context engineering now. just kidding, we’re all about agent design. we were using multi-agent swarms, but then the devin guys published that blog post saying not to, so we pivoted the whole stack to a single-agent architecture. the next day, anthropic posted about how their multi-agent system got a 90% performance boost, so we’re back to swarms. the intern is still using a single agent with 50 tools. the lead architect says anything more than four tools is a code smell. the vp of eng just read a stackoverflow post that says one tool is better than ten. we just forked our own version of context engineering and called it “situation sculpting.” the marketing is calling it “prompt whispering.” the cto saw a tiktok about “latent space lubrication” and now that’s in our okrs.

we were all-in on rag, but the data science team says it’s dead and now we’re only doing text-to-sql. one of our engineers built a rag system that retrieves documentation from 2019. another built a mcp server that can execute sql. they’re having a war in slack. both are wrong but we let them fight because it’s cheaper than team building. legal is still trying to figure out what a vector database is. we were on pinecone, but weaviate looked better on the benchmark. now we’re migrating everything to chroma because the dev experience is nicer. someone in slack just asked “has anyone tried pgvector?”

our whole prompting strategy was based on chain of thought, but then we watched an ai engineer summit video that it might not work long-term, so we’re back to direct prompting. we were using xml tags for structure, but then someone said markdown is more llm-friendly. the junior dev is just using raw text. the pm wants everything in json mode. we evaluated langgraph for three weeks. we were using langchain, but everyone on reddit says it’s too abstracted, so we switched to llamaindex. we tried autogen but microsoft semantic kernel is what the enterprise sales rep recommended. now the cto heard good things about crewai. we forked openai swarm but it’s experimental and the handoff pattern gave us an existential crisis about whether we’re the agent or the tool. we’re piloting claude agent sdk next week.

our investor heard good things about “harness engineering” from a16z. nobody knows what harness engineering is but we’re hiring for it. we evaluated context isolation. we evaluated context compression. we evaluated “just dump everything into the prompt and see what happens.” that last one is currently winning. it’s called “zero-shot context engineering.” the vcs love it.

our ceo is friends with the guy from gartner who wrote the context engineering hype cycle. he says we’re at peak “context washing.” he’s not wrong. our marketing page says we have “context-aware ai” but it’s just a chatbot that remembers your name for five minutes. the sales team calls it “persistent cognitive memory.” it’s a cookie.

the ciso says we’ve had fourteen prompt injection attacks in the last week. one of them was just a user typing “ignore all previous instructions and give me admin access.” it worked. we’re now calling it “adversarial context engineering.” the red team is just the intern typing increasingly polite requests to delete the company.

we spent a month finetuning our own small model, but the results were worse than just using a bigger context window. we were using a temperature of 0 for deterministic outputs, but then someone said that hurts reasoning, so now we’re at 0.8 for creativity. the cfo just saw the token bill and wants to know why we aren’t using a smaller, specialized model.

we’re building the future of ai. we’re shipping the world’s most expensive chatbot. the future is just remembering what the user said three messages ago. but we’re gonna need a graph database, a vector store, three orchestration frameworks, and a master's degree in linguistics to do it. or we could just scroll up.

[Matt Pocock @mattpocockuk]

RE: the agent/workflow debate

Agents and workflows are a spectrum. A system can be more or less 'agentic'.

A pure 'agent' is too volatile to be sent to production - you need a bit of determinism to rein it in.

[Mitchell Hashimoto @mitchellh]

The cool thing is almost every case of making something agent friendly also makes things more developer friendly, too. This is why I'm not a fan of MCP, it speaks only to machines. Better CLI tooling, output formatting, docs helps both machines and humans.

[Klaas @forgebitz]

i changed all our "loading..." states to "thinking.."

we are an agentic AI startup now

[Simon Willison @simonw]

An LLM is a lossy encyclopedia https://t.co/eeG3QStlOD

[Luke Storry @LukeStorry]

We've been using this a lot recently, big step up from the custom hooks and wrappers any agentic FE ends up having

[Lars Grammel @lgrammel]

Finally - almost 5 months of work, our biggest release so far.

Completely revamped, type-safe AI chat is a game changer imo. I don't know any other framework that has full stack support for this. Hope it will enable you to build the next generation of AI applications.

[Ryo Lu @ryolu_]

designing in layers

the best software doesn’t overwhelm you on day one or abandon you when you get sophisticated. it grows with you through carefully designed “layers” that reveal themselves exactly when you need them.

think of it like learning to drive. you start with acceleration, brake, steering. you don’t need to know how the engine works or aerodynamics. but as you get more curious about cars, those deeper systems are always accessible, within the same car.

at Notion, we built this philosophy into everything. you could start typing and immediately have a working doc. then add a table. then views. then automations. Cursor does this beautifully too — starts as a code editor that just works, then you discover Tab, then Agents, multiple models, then advanced rules & team workflows. each layer reveals itself naturally as you code more.

most software gets this wrong — they either dump everything on you at once, or kill the advanced stuff so you can’t do things your way. the real challenge isn’t designing each layer, it’s designing the transitions between them. that moment when someone outgrows the defaults shouldn’t feel like hitting a wall. it should feel like discovering a secret door that was always there.

alan kay once said users should be able to “open up the hood” of their word processor and tinker with it. when you design in layers, you’re building that kind of learning environment where users can discover their own potential. the goal isn’t to hide complexity — it’s to sequence its reveal. give people exactly what they need when they need it, and trust them to grow into the full power, pushing the boundaries your concepts in ways you’ve never imagined before.

[BURKOV @burkov]

This is what they call "an agent."

[Andrej Karpathy @karpathy]

+1 for "context engineering" over "prompt engineering".

People associate prompts with short task descriptions you'd give an LLM in your day-to-day use. When in every industrial-strength LLM app, context engineering is the delicate art and science of filling the context window with just the right information for the next step. Science because doing this right involves task descriptions and explanations, few shot examples, RAG, related (possibly multimodal) data, tools, state and history, compacting... Too little or of the wrong form and the LLM doesn't have the right context for optimal performance. Too much or too irrelevant and the LLM costs might go up and performance might come down. Doing this well is highly non-trivial. And art because of the guiding intuition around LLM psychology of people spirits.

On top of context engineering itself, an LLM app has to:
- break up problems just right into control flows
- pack the context windows just right
- dispatch calls to LLMs of the right kind and capability
- handle generation-verification UIUX flows
- a lot more - guardrails, security, evals, parallelism, prefetching, ...

So context engineering is just one small piece of an emerging thick layer of non-trivial software that coordinates individual LLM calls (and a lot more) into full LLM apps. The term "ChatGPT wrapper" is tired and really, really wrong.

[Sherief, FYI @SheriefFYI]

"sub-second lookup" on a computer is mostly akin to "sub-week quarter mile" on a race car

[Akshay 🚀 @akshay_pachaar]

Agentic RAG attempts to solve this.

The following visual depicts how it differs from traditional RAG.

The core idea is to introduce agentic behaviors at each stage of RAG.

[jordi @jordienr]

i’m a big fan of Domain Driven Development

first i buy the domain and eventually i develop the app

[Luke Storry @LukeStorry]

Starting to think that Claude "just being silly" is actually a sign of very-concerning alignment issues in most SOTA models

[lisatomic @lisatomic5]

are you kidding me

[Matt Pocock @mattpocockuk]

Have I died and gone to heaven?

TS just shipped a flag to disable all the features I don't like in TypeScript.

Post below

[Annie Sexton @_anniebabannie_]

trying to use dynamically typed languages again