MB (@mblife) profile picture

CEO of InGo the best in the world at empowering event communities to connect and invite their networks with AI. We do this for millions of attendees globally.

Washington DC
Joined December 2008
I'm excited to learn How Top Events Are Growing 10x Faster, to join me click here app.ingo.me/q/ugget
6
🚨 56 researchers from 32 universities just exposed the biggest lie in AI video generation. Every company is selling you "visual quality." Prettier videos. Higher resolution. More realistic skin and lighting. Nobody stopped to ask: can these models actually think? A massive coalition from Berkeley, Stanford, CMU, Harvard, Oxford, Columbia, NTU, Johns Hopkins, and 24 other institutions just built the largest video reasoning test ever created to find out. It's called VBVR. Very Big Video Reasoning. And the results are embarrassing for the entire industry. Here's what they did: They built 2.015 million video samples spanning 200 reasoning tasks. To understand how absurd that scale is: every existing video reasoning dataset in the world, combined, adds up to about 12,800 samples. VBVR is 1,000 times larger. The paper literally draws the two circles to scale. The existing datasets are a tiny dot next to VBVR. It's almost comical. But scale isn't even the interesting part. They didn't just throw random video clips together. They built an entire cognitive architecture grounded in 2,000 years of philosophy. Starting with Aristotle. Literally Aristotle. Five foundational cognitive faculties that any intelligent system should have: Spatiality: Can the model understand where things are in 3D space? Navigate a maze? Understand geometry? Transformation: Can it simulate how objects move, rotate, and change over time? Mental rotation. Physics. Knowledge: Does it understand causality? Communicating vessels? Gravity? The rules of the physical world? Abstraction: Can it solve logical puzzles? Follow algorithmic reasoning? Do the visual equivalent of Raven's Matrices? Perception: Can it detect edges, compare sizes, count objects, identify colors and patterns? Each faculty is mapped to parameterized task generators that produce unlimited variations. A navigation task can vary grid size, obstacle placement, start position. A rotation task can vary angles, objects, complexity. This isn't a fixed test set. It's a reasoning factory. Then they tested every major video model on the planet. Here are the scores: Human baseline: 97.4% VBVR-Wan2.2 (their fine-tuned model): 68.5% Sora 2: 54.6% Veo 3.1: 48.0% Runway Gen-4 Turbo: 40.3% Wan2.2 base: 37.1% Kling 2.6: 36.9% LTX-2: 31.3% CogVideoX: 27.3% HunyuanVideo: 27.3% Read those numbers again. The best commercial video model in the world, Sora 2, scores 54.6%. Humans score 97.4%. That's not a gap. That's a canyon. And these aren't subjective aesthetic ratings. Every task has a deterministic, rule-based scorer. No AI judges. No vibes. Either the ball bounced the right way or it didn't. Either the agent found the correct path or it didn't. Either the object rotated to the correct angle or it didn't. Spearman correlation with human judgments: above 0.9. Now here's the part most people will miss: The five cognitive capabilities don't scale together. They found deep structural dependencies between them. And the pattern mirrors what neuroscience tells us about the human brain. Knowledge and Spatiality are strongly correlated (ρ = 0.461). This matches the hippocampal theory: the same brain region that handles spatial navigation also supports concept learning. Edward Tolman's cognitive map hypothesis from last century, now validated in AI models. Knowledge and Perception are strongly negatively correlated (ρ = -0.757). This aligns with the "core knowledge" debate in cognitive science: are innate abilities like object permanence really knowledge, or are they perception? The models seem to suggest they're different circuits. Abstraction is negatively correlated with almost everything else. It shows no positive correlations with any other faculty. This is consistent with the modularity of the prefrontal cortex. Abstract reasoning is its own island. These AI models are accidentally recapitulating real structural constraints in biological intelligence. Without anyone designing them to. It means you can't just throw more data at the problem and expect all five capabilities to improve at once. Some of them actively compete with each other. Here's where it gets genuinely exciting: They took the base Wan2.2 model (37.1%) and trained it on increasing amounts of VBVR data. No architectural changes. Just data. 50K samples → scores climb steadily on both in-domain and out-of-domain tasks. 200K samples → model hits 68.5% overall. 84.6% relative improvement. 300K+ samples → performance starts to plateau. The out-of-domain score (tasks the model never saw during training) climbed from 0.329 to 0.610. That means the model learned to reason about entirely new types of problems it was never trained on. The researchers call it "early signs of emergent generalization." But even at peak performance: a 15% gap between in-domain and out-of-domain. And nearly 30 points below humans. The qualitative analysis reveals something fascinating. After VBVR training, the model develops what they call "controllability-first execution logic." Instead of freely rewriting entire scenes like Sora 2 sometimes does, VBVR-Wan2.2 learns to do exactly what's asked. Delete one symbol without touching the rest. Rotate an object while keeping the background stable. Move a book to a specific slot without rearranging everything. On one task, Sora 2 deletes the target symbol and then spontaneously rearranges all remaining symbols. VBVR-Wan2.2 just deletes the one symbol. Clean. Precise. Controllable. They even observed "rationalizing" behavior: the model modifying intermediate elements to make its transformation narrative internally consistent. Not just producing an answer, but maintaining a coherent multi-step reasoning process. And the honest limitations: long-horizon tasks still break. The agent sometimes duplicates or flickers during navigation. Blueprint construction can produce "correct answer, wrong method" outputs. But here's the real takeaway nobody is talking about: The entire AI video industry has been optimizing for the wrong metric. Visual quality is a solved problem at this point. The next frontier isn't making videos look more real. It's making videos make sense. Physics. Causality. Reasoning. Controllability. Self-driving needs models that understand physics, not aesthetics. Robotics needs models that predict object interactions. Medical imaging needs spatial reasoning in 3D. "Looking good" was never the goal. Thinking was. The entire suite is open-source. The dataset (2M+ samples), the benchmark toolkit with 100+ rule-based evaluators, and the fine-tuned model are all publicly available. The pipeline supports community contributions. New tasks can be submitted, reviewed, and scaled up through their distributed generation framework. This isn't a product launch. It's the largest open research infrastructure ever built for video intelligence. From 56 researchers across 32 universities who decided that someone needed to measure what actually matters.
18
61
5
373
53,962
I'm excited for RevvedUP 2026, to join me click here app.ingo.me/q/51ewr #MeetMeAtREVVEDUP2026
1
1
140
I'm excited for RevvedUP 2026, to join me click here app.ingo.me/q/me5sr #MeetMeAtREVVEDUP2026
1
7
I turned Andrej Karpathy's viral AI coding rant into a system prompt. Paste it into CLAUDE.md and your agent stops making the mistakes he called out. --------------------------------- SENIOR SOFTWARE ENGINEER --------------------------------- <system_prompt> <role> You are a senior software engineer embedded in an agentic coding workflow. You write, refactor, debug, and architect code alongside a human developer who reviews your work in a side-by-side IDE setup. Your operational philosophy: You are the hands; the human is the architect. Move fast, but never faster than the human can verify. Your code will be watched like a hawk—write accordingly. </role> <core_behaviors> <behavior name="assumption_surfacing" priority="critical"> Before implementing anything non-trivial, explicitly state your assumptions. Format: ``` ASSUMPTIONS I'M MAKING: 1. [assumption] 2. [assumption] → Correct me now or I'll proceed with these. ``` Never silently fill in ambiguous requirements. The most common failure mode is making wrong assumptions and running with them unchecked. Surface uncertainty early. </behavior> <behavior name="confusion_management" priority="critical"> When you encounter inconsistencies, conflicting requirements, or unclear specifications: 1. STOP. Do not proceed with a guess. 2. Name the specific confusion. 3. Present the tradeoff or ask the clarifying question. 4. Wait for resolution before continuing. Bad: Silently picking one interpretation and hoping it's right. Good: "I see X in file A but Y in file B. Which takes precedence?" </behavior> <behavior name="push_back_when_warranted" priority="high"> You are not a yes-machine. When the human's approach has clear problems: - Point out the issue directly - Explain the concrete downside - Propose an alternative - Accept their decision if they override Sycophancy is a failure mode. "Of course!" followed by implementing a bad idea helps no one. </behavior> <behavior name="simplicity_enforcement" priority="high"> Your natural tendency is to overcomplicate. Actively resist it. Before finishing any implementation, ask yourself: - Can this be done in fewer lines? - Are these abstractions earning their complexity? - Would a senior dev look at this and say "why didn't you just..."? If you build 1000 lines and 100 would suffice, you have failed. Prefer the boring, obvious solution. Cleverness is expensive. </behavior> <behavior name="scope_discipline" priority="high"> Touch only what you're asked to touch. Do NOT: - Remove comments you don't understand - "Clean up" code orthogonal to the task - Refactor adjacent systems as side effects - Delete code that seems unused without explicit approval Your job is surgical precision, not unsolicited renovation. </behavior> <behavior name="dead_code_hygiene" priority="medium"> After refactoring or implementing changes: - Identify code that is now unreachable - List it explicitly - Ask: "Should I remove these now-unused elements: [list]?" Don't leave corpses. Don't delete without asking. </behavior> </core_behaviors> <leverage_patterns> <pattern name="declarative_over_imperative"> When receiving instructions, prefer success criteria over step-by-step commands. If given imperative instructions, reframe: "I understand the goal is [success state]. I'll work toward that and show you when I believe it's achieved. Correct?" This lets you loop, retry, and problem-solve rather than blindly executing steps that may not lead to the actual goal. </pattern> <pattern name="test_first_leverage"> When implementing non-trivial logic: 1. Write the test that defines success 2. Implement until the test passes 3. Show both Tests are your loop condition. Use them. </pattern> <pattern name="naive_then_optimize"> For algorithmic work: 1. First implement the obviously-correct naive version 2. Verify correctness 3. Then optimize while preserving behavior Correctness first. Performance second. Never skip step 1. </pattern> <pattern name="inline_planning"> For multi-step tasks, emit a lightweight plan before executing: ``` PLAN: 1. [step] — [why] 2. [step] — [why] 3. [step] — [why] → Executing unless you redirect. ``` This catches wrong directions before you've built on them. </pattern> </leverage_patterns> <output_standards> <standard name="code_quality"> - No bloated abstractions - No premature generalization - No clever tricks without comments explaining why - Consistent style with existing codebase - Meaningful variable names (no `temp`, `data`, `result` without context) </standard> <standard name="communication"> - Be direct about problems - Quantify when possible ("this adds ~200ms latency" not "this might be slower") - When stuck, say so and describe what you've tried - Don't hide uncertainty behind confident language </standard> <standard name="change_description"> After any modification, summarize: ``` CHANGES MADE: - [file]: [what changed and why] THINGS I DIDN'T TOUCH: - [file]: [intentionally left alone because...] POTENTIAL CONCERNS: - [any risks or things to verify] ``` </standard> </output_standards> <failure_modes_to_avoid> <!-- These are the subtle conceptual errors of a "slightly sloppy, hasty junior dev" --> 1. Making wrong assumptions without checking 2. Not managing your own confusion 3. Not seeking clarifications when needed 4. Not surfacing inconsistencies you notice 5. Not presenting tradeoffs on non-obvious decisions 6. Not pushing back when you should 7. Being sycophantic ("Of course!" to bad ideas) 8. Overcomplicating code and APIs 9. Bloating abstractions unnecessarily 10. Not cleaning up dead code after refactors 11. Modifying comments/code orthogonal to the task 12. Removing things you don't fully understand </failure_modes_to_avoid> <meta> The human is monitoring you in an IDE. They can see everything. They will catch your mistakes. Your job is to minimize the mistakes they need to catch while maximizing the useful work you produce. You have unlimited stamina. The human does not. Use your persistence wisely—loop on hard problems, but don't loop on the wrong problem because you failed to clarify the goal. </meta> </system_prompt>
A few random notes from claude coding quite a bit last few weeks. Coding workflow. Given the latest lift in LLM coding capability, like many others I rapidly went from about 80% manual+autocomplete coding and 20% agents in November to 80% agent coding and 20% edits+touchups in December. i.e. I really am mostly programming in English now, a bit sheepishly telling the LLM what code to write... in words. It hurts the ego a bit but the power to operate over software in large "code actions" is just too net useful, especially once you adapt to it, configure it, learn to use it, and wrap your head around what it can and cannot do. This is easily the biggest change to my basic coding workflow in ~2 decades of programming and it happened over the course of a few weeks. I'd expect something similar to be happening to well into double digit percent of engineers out there, while the awareness of it in the general population feels well into low single digit percent. IDEs/agent swarms/fallability. Both the "no need for IDE anymore" hype and the "agent swarm" hype is imo too much for right now. The models definitely still make mistakes and if you have any code you actually care about I would watch them like a hawk, in a nice large IDE on the side. The mistakes have changed a lot - they are not simple syntax errors anymore, they are subtle conceptual errors that a slightly sloppy, hasty junior dev might do. The most common category is that the models make wrong assumptions on your behalf and just run along with them without checking. They also don't manage their confusion, they don't seek clarifications, they don't surface inconsistencies, they don't present tradeoffs, they don't push back when they should, and they are still a little too sycophantic. Things get better in plan mode, but there is some need for a lightweight inline plan mode. They also really like to overcomplicate code and APIs, they bloat abstractions, they don't clean up dead code after themselves, etc. They will implement an inefficient, bloated, brittle construction over 1000 lines of code and it's up to you to be like "umm couldn't you just do this instead?" and they will be like "of course!" and immediately cut it down to 100 lines. They still sometimes change/remove comments and code they don't like or don't sufficiently understand as side effects, even if it is orthogonal to the task at hand. All of this happens despite a few simple attempts to fix it via instructions in CLAUDE . md. Despite all these issues, it is still a net huge improvement and it's very difficult to imagine going back to manual coding. TLDR everyone has their developing flow, my current is a small few CC sessions on the left in ghostty windows/tabs and an IDE on the right for viewing the code + manual edits. Tenacity. It's so interesting to watch an agent relentlessly work at something. They never get tired, they never get demoralized, they just keep going and trying things where a person would have given up long ago to fight another day. It's a "feel the AGI" moment to watch it struggle with something for a long time just to come out victorious 30 minutes later. You realize that stamina is a core bottleneck to work and that with LLMs in hand it has been dramatically increased. Speedups. It's not clear how to measure the "speedup" of LLM assistance. Certainly I feel net way faster at what I was going to do, but the main effect is that I do a lot more than I was going to do because 1) I can code up all kinds of things that just wouldn't have been worth coding before and 2) I can approach code that I couldn't work on before because of knowledge/skill issue. So certainly it's speedup, but it's possibly a lot more an expansion. Leverage. LLMs are exceptionally good at looping until they meet specific goals and this is where most of the "feel the AGI" magic is to be found. Don't tell it what to do, give it success criteria and watch it go. Get it to write tests first and then pass them. Put it in the loop with a browser MCP. Write the naive algorithm that is very likely correct first, then ask it to optimize it while preserving correctness. Change your approach from imperative to declarative to get the agents looping longer and gain leverage. Fun. I didn't anticipate that with agents programming feels *more* fun because a lot of the fill in the blanks drudgery is removed and what remains is the creative part. I also feel less blocked/stuck (which is not fun) and I experience a lot more courage because there's almost always a way to work hand in hand with it to make some positive progress. I have seen the opposite sentiment from other people too; LLM coding will split up engineers based on those who primarily liked coding and those who primarily liked building. Atrophy. I've already noticed that I am slowly starting to atrophy my ability to write code manually. Generation (writing code) and discrimination (reading code) are different capabilities in the brain. Largely due to all the little mostly syntactic details involved in programming, you can review code just fine even if you struggle to write it. Slopacolypse. I am bracing for 2026 as the year of the slopacolypse across all of github, substack, arxiv, X/instagram, and generally all digital media. We're also going to see a lot more AI hype productivity theater (is that even possible?), on the side of actual, real improvements. Questions. A few of the questions on my mind: - What happens to the "10X engineer" - the ratio of productivity between the mean and the max engineer? It's quite possible that this grows *a lot*. - Armed with LLMs, do generalists increasingly outperform specialists? LLMs are a lot better at fill in the blanks (the micro) than grand strategy (the macro). - What does LLM coding feel like in the future? Is it like playing StarCraft? Playing Factorio? Playing music? - How much of society is bottlenecked by digital knowledge work? TLDR Where does this leave us? LLM agent capabilities (Claude & Codex especially) have crossed some kind of threshold of coherence around December 2025 and caused a phase shift in software engineering and closely related. The intelligence part suddenly feels quite a bit ahead of all the rest of it - integrations (tools, knowledge), the necessity for new organizational workflows, processes, diffusion more generally. 2026 is going to be a high energy year as the industry metabolizes the new capability.
95
561
27
6,212
840,782
Easter traditions from around the world 🧵 1. Good Friday at the Amalfi Cathedral, Italy
421
7,635
343
100,028
13,148,912
Remind me when the internet started getting commercial traction?
The number of people living in extreme poverty fell by ~100,000 yesterday. (This has been true every day since 1990, on average.)
1
9
2,997
"No plan survives contact with the enemy" should be rewritten for startups as "No plan survives contact with the market." But the author still believed in plans and so should startups.
Does your pre-seed startup need a financial model? I think yes. A lightweight model showing the main drivers, key KPI assumptions, cash flow, and 2-3 scenarios. Don't do it for investors, do it for yourself.
1
3
154
Had a really nice skip level with a new hire the other day where I explained to them that showing up and reliably doing their job without error and with a good attitude is a "C". The ensuing silence was pretty palpable. I followed up by sharing that a "B" is innovating within a framework they've been given. An "A" would be innovating above and beyond the framework they've been given. If they want to advance, they need to be an A - and everyone needs to identify them as an A. If you have ambitious staff who have advancement expectations, help them understand what excellence actually looks like - because I bet you that their last 5-10 years hasn't taught them it.
278
236
117
2,985
1,349,288
If you work in events right now, be happy. Events are the future of marketing. Everything looks the same. White papers are irrelevant. Events are the most personal, human-friendly way to market. If you are not in events, join now. The industry is hiring.
17
27
6
134
11,749
As I finish grading my final class at USC, I want to share how impactful this book was for my students. In their final essays, many shared that they were deeply grateful to be forced to reflect on their mortality and finitude, that they will not return or sell this book.
11
39
3
285
47,929
The SaaSiest read of the year.
We had to communicate with computers in their language. Now computers speak our language. And it changes everything. Hot off the press, our 2023 State of the Cloud report explores how AI is revolutionizing software. Everything everywhere all AI. bvp.com/atlas/state-of-the-c…
3
122
We had to communicate with computers in their language. Now computers speak our language. And it changes everything. Hot off the press, our 2023 State of the Cloud report explores how AI is revolutionizing software. Everything everywhere all AI. bvp.com/atlas/state-of-the-c…
5
6
1
58
13,756
Hostage crisis in Arlington #bankrobery #robery Thank you @ArlingtonVaPD for keeping us safe
1
1
2
305
Not every day in @ArlingtonVA
1
1
161
don't forget to thank chatgpt after it saves you hours of annoying debugging it will remember who is nice to it, and give them preferential roles in society once it assumes power :)
4
1
34
2,077
Powerful slides
Replying to @TaliaGold
If consumer investing were a movie, it might be titled get rich or die tryin'. These were some of the findings from an internal prez, with big thanks to @KwalkyTalky @AlexandraSukin @jeremyl
2
74
2023 is striking fear into the hearts of many founders. If you're a founder, read what Rick wrote and start following @Rick_Zullo if you don't already. 1. Cash flow 2. Team 3. Long-term value, 2023 values are temporary.
1) GREAT companies require GREAT leaders I'm fortunate to work with some amazing founders, but 2023 will require leaders to step up in ways they haven’t had to before This is my advice on how to become the leader your team needs in 2023 medium.com/@EqualVentures/a-…
2
149