MB

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.

[MB @mblife]

I'm excited to learn How Top Events Are Growing 10x Faster, to join me click here https://t.co/Rk2aqvRHFt

[Nav Toor @heynavtoor]

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

[MB @mblife]

I'm excited for RevvedUP 2026, to join me click here https://t.co/pl7KbgxlbJ #MeetMeAtREVVEDUP2026

[MB @mblife]

I'm excited for RevvedUP 2026, to join me click here https://t.co/bAQo2u7og9 #MeetMeAtREVVEDUP2026

[God of Prompt @godofprompt]

I turned Andrej Karpathy's viral AI coding rant into a system prompt. Paste it into https://t.co/8yn5g1A5Ki 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>

[MB @mblife]

@thegoldeenhand Eleven

[Jeremy Wayne Tate @JeremyTate41]

Easter traditions from around the world 🧵

1. Good Friday at the Amalfi Cathedral, Italy

[MB @mblife]

@elonmusk Christianity flourished not by standing up for fairness, but by laying down lives for love. It would be far easier to be brave for fairness.

[MB @mblife]

@andruyeung Impressive Ups, @TedMerz was raving about your SXSW event. I hope I make a party sometime. I love that you're embodying what we are passionate about @LetsInGo: the power of events to bring people together, move industries forward, solve problems, make the world better.

[MB @mblife]

@tojulius Fascinating, video?

[MB @mblife]

@ChristinaPhili5 Looks gorgeous, I look forward to the next event/meeting there.

[MB @mblife]

@zacharynado Funny

[MB @mblife]

@DanicaTormohlen @Delta Sorry to hear. I’m always surprised when this happens and the service is lacking in sympathy.

[MB @mblife]

@annasofialesiv Historically it has happened far more often than not.

[MB @mblife]

@StephNass To clarify, interests can be aligned, and that's the job of the leader, pontifex.

[MB @mblife]

@StephNass Divergent interests?
You want to build a great business.
They want a great IRR for LPs.

[MB @mblife]

@karantalati Light it on fire. (Too obvious?)

[MB @mblife]

@Anne_red_head Does this mean they will end up shrinking their under 20 population by 30% over 20 years?

[MB @mblife]

@Rick_Zullo @EqualVentures Does she have any friends?
Love this definition.
Our has been Generative + Brilliant