A query on a warm working set never touches S3.
How @ObsessionDB does it, as a visual lesson from their docs: https://t.co/JlY6r2YV2Y
Ask it questions, and it updates when the docs change.
Make one from your docs: https://t.co/olMTNVkOHG
Wrote a Medium post explaining how something works?
I’ll turn it into a visual lesson, free.
Embed it on your site or in your posts, or share the link. Readers can ask it questions about your article.
Articles that work best:
- System design and architecture breakdowns
- “How X works” deep dives (databases, networking, compilers, ML models)
- Data pipelines, request flows, distributed systems
- Any concept with moving parts that’s easier to show than describe.
Reply 👇
Building a dev tool with an architecture page nobody reads?
Send me the link. I’ll turn it into a narrated visual lesson for free, ready to embed in your docs.
Or try it yourself: https://t.co/olMTNVkgS8
Dev-tool founders: send me the one docs page your users never quite get.
I’ll turn it into a free narrated visual lesson that embeds in your docs/README. They play like a video, but every frame is live: developers can pause and ask, answered from your docs.
Small pilot, 10 teams. Reply with the link. 👇
You know the feeling. You open the docs, a spec or a PDF, and by the second paragraph it’s using five terms nobody ever explained.
We just shipped something for exactly that at @OpenLume .
When you ask a question now, you can attach the material you’re stuck on:
a PDF, a screenshot, your notes, even a YAML, Terraform or Dockerfile.
OpenLume builds the video from that, not from some generic explanation. It reads the diagrams and charts too, and if it has to fill a gap with general knowledge, it tells you which parts.
I’d really like you to try it on something you wanted to understand 👇👇
What actually happens when you run `terraform apply`? A quick visual walkthrough of how Terraform turns configuration into real infrastructure changes. #Terraform#DevOps
Why does Terraform need a state file? A quick visual explanation of how Terraform tracks real infrastructure, compares it with your configuration, and decides what to change. #Terraform#DevOps
Kubernetes Pods keep dying and getting new IP addresses.
So how does anything reliably connect to them?
That problem is exactly why Services exist.
Here’s the traffic flow visually, made using @OpenLume#kubernetes#devops
Pod. ReplicaSet. Deployment.
Three Kubernetes objects that look like they’re doing almost the same thing.
They aren’t.
Here’s why Kubernetes needs all three.
#kubernetes#devops#containers
You create a Kubernetes Pod.
Who decides which node runs it?
And when it crashes, what actually brings it back?
I made a short visual walkthrough of the full scheduling + recovery path with @OpenLume.
Why are some technical explanations so hard to follow?
Sometimes the video tutorial is technically correct, but you still lose the thread halfway through.
The voice is flat. The pacing is off. Nothing gets enough emphasis, so your brain has to work harder just to follow along.
That’s the part I’ve been trying to fix.
New @OpenLume explainers now sound much more natural and teacher-like, with better pacing, pauses and emphasis around the parts that actually matter.
They also include a small question during the explanation, so you get a quick chance to check whether the idea really clicked. You can answer it, take a moment, or just listen while the narrator explains it and carries on.
Think of one technical concept you’ve been meaning to understand properly and give it another go in OpenLume 👇
We talk a lot about vibe coding. I think we need to talk about vibe reviewing too.
You ask AI to review a PR. It finds a few issues, explains them, and suggests fixes. Your coding agent makes the changes. The reviewer is happy. You skim the summary and approve.
You haven’t really read the code. But the review happened, the checks passed and the explanation made sense.
That feels like vibe reviewing to me.
@karpathy’s original vibe coding post described letting AI handle the implementation without reading the diffs. Vibe reviewing takes that a step further. We trust AI to tell us whether the implementation is good enough too.
After a decade in software engineering, I find that a bigger shift than getting AI to write the code.
Writing code and deciding whether to trust it have always been different responsibilities. A review was a chance for someone else to understand the change, question the assumptions and spot what the author missed.
With vibe reviewing, that second understanding may belong to another agent.
One agent writes the code. Another challenges it. They go back and forth. We see the conclusion.
I can see the appeal. Reconstructing the context of a change takes real effort. When agents can produce several changes while you’re still understanding the first one, you start wondering how much of that understanding you need to build yourself.
And honestly, human review has never been a guarantee either. We’ve all seen an LGTM on a change that deserved a closer look.
What interests me is what happens to the approval.
The button is the same. Your name is still attached to it. But you may now be saying “I trust the agents and the checks” rather than “I understand this change well enough to approve it.”
That’s a meaningful change in responsibility, even if the workflow looks familiar.
Two agents agreeing could give us more confidence. They could also share the same wrong assumption. A clear summary won’t necessarily tell us which happened.
I don’t have a neat answer for where that trust should stop.
@ContactShadab This is something we think about a lot at @OpenLume too.
Before giving someone more logs, traces or docs, help them build the right mental model first.
This is something we think about a lot at @OpenLume too.
Before giving someone more logs, traces or docs, help them build the right mental model first.
One pattern I have noticed over years of debugging production incidents:
Most engineers start with the tools.
Open alerts. Search logs. Check metrics. Look at traces. Maybe jump into the source code.
Experienced troubleshooters usually do the opposite.
First look at the error and symptoms and form 2 or 3 hypotheses about what could be happening.
Then go to logs, metrics, traces and code looking for evidence to prove or reject those hypotheses.
This sounds like a small difference, but during a real incident it changes everything.
Without a hypothesis, you are mostly searching.
With a hypothesis, every query has a purpose.
Observability tools give you evidence.
Debugging is still a reasoning problem.
@ContactShadab The more AI writes, the less code becomes the bottleneck. Understanding does.
@OpenLume is built for that shift. Ask how a system works, and get the architecture, flow and concepts explained visually until they actually click.
The more AI writes, the less code becomes the bottleneck. Understanding does.
@OpenLume is built for that shift. Ask how a system works, and get the architecture, flow and concepts explained visually until they actually click.
Abstraction over abstraction over abstraction. I am tired of software engineering.
Now add AI coding agents on top of all this. They are generating code against abstractions we barely understand ourselves.
You start with a simple problem. Somehow you end up with a framework on top of a library on top of an SDK talking to a managed service running on Kubernetes behind a load balancer with retries, queues, caches, service discovery and three layers of config.
Most of the time you do not even know half of it exists.
Everything looks clean while it works. Then something breaks and suddenly you are debugging a connection pool, DNS, some hidden retry, a container limit, an SDK timeout, or cloud behaviour you never even knew was part of your system.
We keep saying abstractions make software easier. Maybe they do when everything is healthy. But mostly they move complexity somewhere else until nobody really has the full picture anymore.
And now agents can generate and change these systems faster than we can understand them.
Good. Fast. Cheap. Pick two.
If engineers have to fully own AI generated code and reviewers partially own everything they approve, I suspect “fast” is the one that starts disappearing 😄
I’ve spent most of my career close to infrastructure, build systems and developer tooling and I think there’s an important idea underneath this thread.
Software engineering isn’t disappearing. The abstraction boundary is moving again.
We moved from assembly to higher-level languages, from servers to cloud, from manual infrastructure to declarative systems. Each time, engineers stopped caring about some details and became responsible for a larger system.
Agents are another, much bigger, jump.
When an agent can produce thousands of lines of code in minutes, reviewing every line stops scaling. The interesting questions move up a level:
1/ Does the system do what we intended?
2/ What assumptions did the agent make?
3/ What happens under failure, load or partial degradation?
4/ Are the boundaries and dependencies right?
5/ Can we observe it well enough to know when reality diverges from intent?
I’m less convinced that tests, terminals or code review simply “die.” Their role changes. We’ll test behaviour more than implementation. Review intent and architecture more than syntax. Observability becomes part of verification, not something added after deployment.
And I think one skill becomes more valuable: building a mental model of a system you didn’t personally write.
That’s something I’m thinking about a lot while building @OpenLume too. If agents increasingly produce the implementation, humans need better ways to understand the architecture, flows and decisions around it. Maybe visually, interactively, without reading 20,000 lines of generated code?
The engineer of the future may write far less code. But they’ll need to understand far more software.