Ingo retweeted
1. Oh shit, AI can do my job better than me
2. Software engineering is dead!
3. I can vibe code as much slop as I want!
4. Oh, things are not going well. Fable/Sol/Opus all suuuck
5. But what if I constrain the agent? Put it in a straitjacket?
6. Oh, the results are pretty good now. How do I go deeper?
7. *Orders 12 software engineering books from Amazon*
8. Software engineering is alive!
Ingo retweeted
China published the most uncomfortable paper on vibe coding.
ETH Zurich tested 100 developers in a controlled, commercial-grade vibe coding environment to see who actually succeeds.
The findings are brutal.
The researchers tracked computer science achievement, written communication skills, and general cognitive reasoning.
They wanted to see what actually predicts vibe coding proficiency when you never touch a line of source code yourself.
Two major predictors emerged.
Written communication proficiency mattered. The ability to structure thoughts and articulate intent unambiguously in text directly impacts what the AI builds.
But that wasn't even the main takeaway.
Computer science achievement was a massive, dominant predictor of success.
Even when researchers controlled for general intelligence and reasoning skills, CS background still heavily dictated who built working software and who completely crashed.
In fact, CS knowledge contributed roughly twice the unique predictive variance of writing skills alone.
Why? Because vibe coding isn't about writing code. It’s about debugging logic.
When an AI agent builds a complex application and quietly breaks an edge case under the hood, a non-technical user looks at the glowing UI and assumes it works.
They don't know what questions to ask. They don't know what logic to challenge. They lack the mental models to recognize architectural catastrophe.
You can prompt your way past syntax.
You cannot prompt your way past a fundamental lack of engineering intuition.
The hype told us that learning to code is dead because language is all you need.
The data just proved the opposite.
To truly master the vibe, you still need to understand how the machine thinks.
Ingo retweeted
ripwire, from Red Hat Emerging Technologies, is a remarkably substantial new approach to giving coding agents repository context without embeddings, a vector database, an LLM indexer or a daemon. The zero-dependency C++23 binary parses 21 languages with Tree-sitter and builds a deterministic structural map of a codebase, ranking symbols for the task while attaching call relationships, complexity, git churn, change amplification and test coverage.
An agent can ask what matters for "incremental cache invalidation," for example, and receive the relevant symbols, their callers, likely blast radius and tests to run in a token-budgeted response instead of grepping and opening files repeatedly.
GitHub Repo: github.com/redhat-et/ripwire
Ingo retweeted
We've spun up an exploratory platform where you can find an experimental open-weight LLM inference API. Free, no SLAs. Test your own use cases and tell us what works and what doesn't 🫡
No promises this becomes a permanent product: htznr.li/xprmnts_x
Ingo retweeted
We’ve decided to open-source a multi-agent harness we use internally at YC.
We call it “QM” and it’s meant to be easy to customize, like Hermes or OpenClaw, but useful for a whole company. We use it across accounting, legal, events, and engineering (including building QM itself!).
The whole project is under an MIT license. It is cloud-first and has Slack and web UI natively.
Ingo retweeted
We ran Kimi K3 through 3 agent harnesses (Claude Code, Hermes, Kimi Code) on 28 identical tasks.
All 3 harnesses completed the tasks at similar success rates, but the interesting story is token efficiency: the same task cost up to 30x more tokens depending on the harness. 🧵🧵
Ingo retweeted
CodeCrucible: A blueprint for LLM-driven SAST
engineering.block.xyz/blog/c…
Ingo retweeted
this is f**king insane
a free github repo by Jack Dorsey (Co-Founder of Twitter) with 14.4K stars just dropped the entire "ai-agent" framework for running businesses
here is how you set it up:
1.clone the repo
2. self-host the server : channels, search, git, automation all live there
3.add your agent to a channel like a teammate, scope its key, let the team steer it live
save and bookmark this no matter what
Ingo retweeted
Another WTF moment.
A developer just open-sourced a coding agent harness that boots 245x faster than Claude Code. It's called jcode. You launch it and the first frame renders in 14 milliseconds. Claude Code takes 3,436. One active session uses 27.8 MB of RAM. Claude Code uses 386.6. Run ten sessions in parallel and jcode holds at 117 MB while OpenCode swells to 3.2 GB.
Each agent has a semantic memory graph instead of a scratchpad. Every turn gets embedded as a vector. The graph is queried on every turn for related memories, and a sideagent verifies the hits before injecting them into context. Consolidation runs in the background to check for stale or conflicting facts. No manual /remember calls. No token burn on lookup tools.
The provider list is 30+ deep. Claude, ChatGPT, Gemini, GitHub Copilot, Azure, OpenRouter, DeepSeek, Groq, Mistral, Perplexity, Fireworks, Ollama, LM Studio, and any OpenAI-compatible endpoint you point it at. Ran out of tokens on your first ChatGPT Pro sub? /account swaps to the second.
Then there's Swarm. Spawn two agents in the same repo and the server manages them. When agent A edits a file agent B has been reading, agent B gets pinged and can check the diff. Agents can DM each other, broadcast to the room, or spawn their own worker teams for parallel tasks. Groups, channels, and completion statuses are handled automatically.
The UI has live side panels that render mermaid diagrams inline. To make it fast, the author wrote a Rust mermaid renderer 1800x faster than the JavaScript one, then wrote a custom terminal called Handterm because no existing terminal could do smooth partial-line scrolling.
Self-dev mode is where it gets wild. Tell your agent to enter self-dev and it starts editing jcode's own source code, rebuilds the binary, reloads it live, and keeps working across your existing sessions. You can also resume broken sessions from Claude Code, Codex, OpenCode, or pi directly inside jcode. Anthropic's cache goes cold at the 5-minute mark and you're staring down a big cache miss on your next turn? The UI warns you before you spend the tokens.
Written in Rust. MIT licensed. Runs on macOS, Windows, Linux, and Termux. Sitting at 11.2k stars with a native iOS app coming.
github.com/1jehuang/jcode
Ingo retweeted
What if I told you…
you could open a 200,000-line legacy codebase and instantly understand it — without reading most of it?
Sounds impossible, right?
That’s exactly why this is blowing up.
A GitHub Trending #1 project — Understand Anything (21.8k stars) — is quietly turning entire codebases into something completely different:
Not files.
Not folders.
But an interactive, queryable system of logic.
You don’t browse code anymore.
You ask it questions.
• “What does this module actually do?”
• “Where does the payment flow start and end?”
• “Who depends on this function?”
• “What breaks if I change this?”
And instead of dumping files at you, it traces the real structure of the system and answers directly from it.
Then comes the real shift:
Before making changes, you run "/understand-diff"
And it shows:
• exactly which modules will be affected
• hidden dependency chains you would never notice
• potential breakpoints before they become production incidents
No guessing. No blind edits. No “hope this doesn’t break anything”.
It plugs directly into Claude Code, Cursor, and VS Code — so it lives where you already work.
But the real transformation is deeper:
You stop reading code to understand it.
And start interacting with it like a system that already understands itself.
Once you experience that…
traditional codebases feel broken.
Repo👇
Ingo retweeted
POV: claude traveled 6 months into the future and told you exactly how your next move failed.
it's called a premortem.
daniel kahneman (nobel prize-winning psychologist behind "thinking fast and slow") called it his single most valuable decision-making technique.
when you ask claude "is this a good plan?" it finds all the reasons to say yes.
that's what it was trained to do (to be helpful and agreeable). so you walk away feeling confident.
you execute, and spend weeks / months building on top of that plan.
then it blows up.
and you realize the problem was obvious in hindsight, you just never stress-tested it because claude told you it was solid.
a premortem fixes this by flipping the frame.
instead of asking "what could go wrong?" you tell claude "it's 6 months from now and this is already dead. tell me how it died."
that shift turns off claude's optimism because there's nothing to be optimistic about. the premise already says it failed.
so claude stops looking for reasons your plan will work and starts explaining how it fell apart.
claude comes back with every way your plan could die, each one with a full failure story and the early warning signs to watch for.
then a synthesis pulls it all together:
> which failure is most likely
> which failure is most dangerous
> the single biggest hidden assumption you're making (often the most valuable part)
> a revised version of your plan with the gaps closed
you say "premortem this" and give it your plan. the skill handles the rest.
Ingo retweeted
NEWS: Chinese robot company Unitree has unveiled their new low-cost R1 humanoid robot.
• Starting price: $5,900
• Weight: 55 lbs (25kg)
• 26 joints
• 4 feet tall
• Battery life: 1 hour
• 8-core CPU + GPU
• Warranty: 8 months
• 4-mic array
• Equipped with multimodal AI that includes voice & image recognition
• Humanoid Binocular Camera: Ultra-Wide-Angle Visual Perception
Ingo retweeted
Good morning! Super excited about today, starting with @pcalcado opening up day two at InfoQ Dev Summit Boston! #infoqdevsummit
Ingo retweeted
Apple wrote a paper claiming that reasoning LLMs create an illusion of thinking…
Fundamentally the point is that these thinking LLMs can solve arbitrarily complex problems even when given a large number of tokens
This is not surprising. Thinking LLMs have a plateau based on the patterns that they can generate and attribute confidence scores too
The is why they still hallucinate
Ingo retweeted
After the initial sugar rush, expensive models end up getting little or no usage.
GPT 4.5 - was barely used before being retired
o1 - was too slow and expensive to be used IRL
Veo-2 - abandoned, gave people sticker shock
o3 - only used as a fallback or for planning
Veo-3 and Opus will likely meet the same fate.
AI labs should abandon these big models. It's not worth the R&D expenses
Ingo retweeted
SYSTEM PROMPT TRANSPARENCY FOR ALL #CL4R1T4S
github.com/elder-plinius/CL4…
