writing video timelines as React components felt a little weird at first, but rendering programmatically with @Remotion is strangely addictive.
no dragging clips across a bloated timeline or waiting on heavy editing suites to export.
just interpolate(), spring physics, and CSS. hit render, headless Chromium + FFmpeg takes over, and out comes a crisp 60fps video.
being able to git commit a video edit is such a nice feeling 🤍
it’s so interesting watching the industry consensus shift from "namespaces and cgroups are enough" to "agents genuinely need their own microVM."
when an autonomous agent is installing packages and running build scripts in the background, true hardware-assisted kernel isolation is the only way teams will ever trust them with real workloads ✨
the idea of an agent starting with just a bare shell, writing its own helper scripts as it discovers the problem, and modifying its own code is so delightfully wild.
one file and standard library only makes it something you can actually read and audit in five minutes instead of wading through layers of framework abstractions. congrats on shipping 🤍
watching frontier models actively route around predefined tools just to write inline python scripts was such an obvious signal that traditional harnesses were getting in the way.
having a persistent REPL where variables, helper functions, and data frames actually survive across turns eliminates so much context thrashing. 71.2% on Terminal-Bench with lower dollar cost is huge proof of work 🤍
@uixmat@bklitai particle reveals on SVG line charts look so ridiculously clean.
most dashboards just do the default left-to-right path draw, but having subtle particles dissolve along the stroke gives it that high-polish tactile feel. really beautiful recipe ✨
11,000 PRs in a month is wild, but that 0.5% revert rate is the actual flex here.
usually when PR volume explodes like that, codebases quietly turn into a fragile mess.
keeping reverts that low while the app actually gets faster is proof that good guardrails and verification save you so much pain. such inspiring work 🤍
"the specs come from what people want, not math" is so real. you can have mathematically verified code that still does the completely wrong thing because the human asked for the wrong thing.
making the state machine visible before touching code is such a lifesaver though. most subtle bugs i run into aren't syntax errors, they're just weird transition states nobody realized were reachable.
pairing statecharts for intent with real test runs feels like the sweet spot 🤍
@ziwenxu_ having to type out an entire for loop with your own human fingers without pressing tab is a traumatic experience 💀 been there recently 🥲
stay strong 🤍
the restaurant analogy is good.
anyone can follow a recipe with an air fryer, but you can immediately tell when food was made by someone who actually understands heat and seasoning.
it’s the same with code. letting an agent draft syntax is fine, but someone still has to care enough to look at a working PR and say "this passes tests, but it feels gross, rewrite it" 🤍
the strictest invariant we set for Anode was: user Go backends must never import an anode package.
most developer platforms force you to import their SDK, wrap your HTTP router, or litter your code with custom annotations.
instead, Anode reads your raw Go source with SSA and AST static analysis:
• detects your database from https://t.co/eGHamVdmYk driver strings
• finds listening ports by tracing router bindings
• traces os.Getenv calls backward to identify required secret keys
your backend stays 100% pure standard Go. if you ever stop using Anode, not a single line of your code needs to change 🤍
the easiest way to make AI coding agents 10x more reliable is removing primitive strings and boolean flags from your domain types.
when a function takes:
func ProcessOrder(id string, retry bool, status string)
agents will silently hallucinate argument order and tests will pass right up until runtime.
when you wrap them in nominal types:
func ProcessOrder(id OrderID, opt DeliveryMode, state OrderState)
the compiler catches 90% of agent hallucinations instantly before a single test runs.
strong types aren't just for humans anymore; they're the cheapest prompt guardrails you can write.
the older i get, the more i appreciate things that are delightfully physical and just work without an account.
- a good mechanical pencil that never needs bluetooth pairing.
- a pocket paper notebook that doesn’t run out of battery.
- a heavy ceramic mug of pour-over that doesn’t ping you for a firmware update.
simple tactile habits keep you sane when the rest of your week is spent manipulating invisible bits in the cloud.
ran a fun little test on my laptop running 12 Go microservices:
Option A: with Docker
• RAM: ~480 MB (mostly docker engines and network bridges)
• Boot time: ~3.8 seconds
• Laptop fan: audible whoosh 💨
Option B: straight on Linux with cgroups v2
• RAM: 36 MB (literally 92% less!)
• Boot time: 42 milliseconds ⚡
• Laptop fan: dead silent
it’s amazing how fast and light software feels once you let the operating system do what it was designed to do ✨
the biggest hidden tax in agentic workflows is cold-start amnesia—watching an agent burn 15,000 tokens every session just rediscovering how the repo is structured.
git-backed persistence so agents actually retain learned skills and discovery notes across runs is the exact layer the ecosystem needed. congrats on 1k 🤍
the worktree model in orca is so nice for parallel runs.
the next friction point is usually local state collisions—when three sub-agents finish code and try to run integration tests against the same local port.
would love to see ephemeral port allocation or loopback binding per worktree so background agents can run test servers without tripping over each other ☕
@nwparker_ being able to zoom in and follow sub-agents is so nice! once you have a few background agents running at the same time, seeing their execution tree in real time makes it way less of a black box 🤍
leaving your phone on your desk and taking a 30-minute walk with no headphones is basically a factory reset for your brain.
no podcasts, no notifications, no context switching.
just noticing the evening air and watching street dogs do their neighborhood rounds. probably the highest ROI 30 minutes of the entire weekend.
asking AI coding agents for the "smallest possible diff" quietly makes codebases worse over time.
a quick bandaid fix patches the bug, but it also poisons the context window. the next agent reads that shallow hack, assumes it’s "how we do things here," and multiplies the pattern across 5 other files.
typing code used to be expensive, so humans loved bandaids. but when refactoring costs $0.002, asking the @bot to fix the root abstraction is the real superpower ☕✨
maybe a hot take but having an interface for every single class when there’s only one implementation is pure cognitive bloat.
UserService ──► UserServiceImpl
PaymentService ──► PaymentServiceImpl
half the files in the repo exist solely to declare methods that are immediately implemented 10 lines away.
deleting the 1:1 interfaces and using ArchUnit to keep things flat makes codebases 40% more readable overnight ☕
do you still write *ServiceImpl? be honest 😂