Disala Sennath

Founder & CEO of Granetra
Betting my life on ideas most people think are too early.

[Disala Sennath @eapyk]

@mr_pool4 @grok AI or Real ?

[Disala Sennath @eapyk]

The key is model efficiency. If Sol/Luna are 50% cheaper and more capable, half the API-dollar allowance doesn’t automatically mean half the actual work.

The real test is simple if users hit the weekly cap sooner, it’s a downgrade. If they get more completed work before the cap, the change worked.

[Disala Sennath @eapyk]

Tomorrow the $200 Pro plan is reopening, but the usage economics are changing.

The simple version:

• The new Pro plan gives roughly 50% of the old API-dollar-equivalent usage.
• GPT-6 Sol and Luna are now ~50% cheaper, so that doesn’t necessarily mean 50% less actual work.
• The 5-hour limit is NOT coming back.
• More subscription features are coming that won’t consume usage at all.

So on paper the allowance is lower, but because models are getting cheaper and more efficient, the goal is for users to still get the same or more real work done for $200.

The real test will be simple: how much actual Codex work can we do before hitting the weekly limit?

[Tibo @thsottiaux]

Hi,

Tomorrow we are re-opening the Pro $200 subscriptions to new subscribers, but together with it we are also changing how we calculate the usage for it. In effect, if you do the math, it will net out at half the dollar in API spend compared to the old Pro $200 plan.

Now that it's said, let me explain why this is happening and why you will still get more work done than if you were on the Pro $200 subscription one month ago.

(a) We didn't want to compromise in other ways and are committing to not reintroducing the 5h limit, so that you can fully use the weekly usage when you want.
(b) On the subscription, we guarantee that over time you always get more work done and with an increasing level of quality. This means that you will continue to get more value per dollar spent as a result of models getting more efficient and us passing down the improvements in the form of API price reductions.
(c) We don't want to put an incentive on ourselves to artificially inflate the API list prices to make it look like you are getting a lot (and workaround it through discounts, etc). Instead we want to continue to both rapidly reduce prices and increase capabilities of models on the API. This week we introduced GPT-6 Sol and GPT-6 Luna at 50% of their previous price. Over time, we see prices go low enough that it makes sense for most to buy usage as needed without there being a significant gap between what you get in a subscription and what you get in the API for a dollar spent.
(d) Tomorrow, we are adding more things to the subscription that won't draw on the usage, I won't reveal what that is yet.

I wanted to be transparent before all the big announcements tomorrow. Lots of new exciting things are coming to the subscriptions that will make it super compelling, but I wanted to make sure to share this change ahead of time so you can all understand it before we shower you with good news.

Codexingly,
Tibo

[Disala Sennath @eapyk]

Really interesting conversation with Jensen Huang.

What stood out to me is how differently he talks about AI compared to a lot of people in the industry.

He doesn’t treat AI like some mysterious uncontrollable thing. His view is much more practical: it’s an engineering problem. You build it, test it, verify it, improve it, and if it isn’t safe or reliable enough yet, you don’t ship it.

He also breaks the AI industry into five layers:

Energy → Chips → AI infrastructure → Models → Applications.

The application layer is the part I find most interesting.

Models will keep getting better, but the real value comes from turning that intelligence into something people and businesses can actually use.

Great conversation. Worth watching.

[Disala Sennath @eapyk]

@ah20im are you tibo 2 ?

[Disala Sennath @eapyk]

If this is already real today, just imagine what 2030 is going to look like.

[Eco @IndependentEco]

Astra 6.1 is dropping on Tuesday and rumors have it mogging Opus 5.5

If this is true we are about to experience take off.

Tibo is confident in the OpenAI response and has even replied to a post that said OpenAI has no shot against Opus.

I bet we see Fable 5.5 in response to Astra 6.1 then Bel in response to Fable.

We are about to go parabolic.

[Disala Sennath @eapyk]

@Da7_Tech i think 100% is the right answer

[Disala Sennath @eapyk]

You are not the same person you’ll be 10 years from now.

Your goals will change.
Your priorities will change.
Your definition of success will change.
So don’t build a financial life that traps your future self into decisions your current self made.
Save room to change your mind.

That flexibility is a form of wealth.

[Disala Sennath @eapyk]

@VadimStrizheus someone know balls

[Disala Sennath @eapyk]

@alexandr_wang BRO....

[Disala Sennath @eapyk]

@ameliom612 @thsottiaux

[Disala Sennath @eapyk]

@ameliom612 @thsottiaux now

[Disala Sennath @eapyk]

@thsottiaux saint tibo for a reason

[fahmeedx @fahmeedx]

druski genuinely saying some real shit here

[Disala Sennath @eapyk]

@StatsWire I think right now its better to not cancel my subscription just wait until devday

[Disala Sennath @eapyk]

@iamvishal16_ios That’s the shift. The prompt can compress 10 years of execution into seconds but it still can’t compress 10 years of taste.

[Disala Sennath @eapyk]

I kept seeing these ridiculously clean Claude Opus 5.5 motion videos all over X, so I spent some time digging into how people are actually making them.

Turns out the interesting part isn't really the video.

Opus 5.5 isn't generating the pixels like Sora, Veo, Seedance, etc.

It's writing the software that generates every frame of the video.

And after looking through the original posts, prompts, repos and creator replies, there are basically a few different workflows emerging.

The simplest one is almost stupidly easy.

One of the prompts that helped kick off the trend was literally:

“make a dynamic 15-second motion graphics video that shows what an incredible motion designer you are, like it's your showreel for a résumé. go all out.”

That's basically it.

People gave that to Claude Code + Opus 5.5 and it started producing full motion reels with:

kinetic typography
shape morphing
generative graphics
particle systems
UI animation
3D scenes
camera movement
motion blur
beat-synced transitions
and proper end cards
Sometimes from almost no human direction.
But here's where it gets more interesting.
There are basically TWO main technical approaches behind a lot of the best clips.
1. HTML/JS + Playwright + FFmpeg
This is probably my favorite.
Claude builds the whole animation as code.
But instead of using normal browser animation like:
setInterval
CSS transitions
requestAnimationFrame
the animation is built as a deterministic function of time.

Basically:

seek(t)

Give the animation a timestamp and it knows exactly what the entire frame should look like at that moment.

So if you ask:

seek(6.95)

every object, letter, cursor, shape, camera position, spring and UI state is calculated for exactly 6.95 seconds.

Then Playwright launches Chromium and renders the animation frame by frame.

For a 15-second video at 60 FPS:
15 × 60 = 900 frames.
Claude can render all 900 individually.

And some workflows go further.

Instead of rendering only ONE image for each frame, they render multiple tiny time samples around that frame.

For example:

frame 417
417.00
417.25
417.50
417.75

Then FFmpeg blends those samples together.

That's how they're getting proper motion blur without just throwing a CSS blur filter over everything.

This matters way more than it sounds.

You're not screen-recording a browser hoping Chrome maintains 60 FPS.

Frame 417 is literally calculated directly.

Frame 418 is calculated directly.

Frame 419 is calculated directly.

So the final render is deterministic.

No dropped frames.

No weird animation timing.

No recording stutter.
Typography stays razor sharp.
2. React + Remotion + Three.js
The other big workflow is more like building a mini motion-design studio in React.
Something like:

Claude Code
→ React
→ Remotion
→ Three.js / React Three Fiber
→ FFmpeg

Remotion basically lets you create video compositions using React components.

Instead of animation depending on real-world time, everything is driven by the current video frame.

So Claude can write things like:

frame 0–120 → intro typography

frame 120–240 → morph into product UI

frame 240–360 → camera pushes through UI

frame 360–500 → Three.js scene

etc.

This becomes especially powerful when you start combining normal UI with WebGL/3D.

One of the Claude reels I found literally disclosed its stack on-screen:

REACT
REMOTION
THREE.JS

with the claim that the whole thing was made in code.

And that's why some of these videos can jump between typography, UI, particles, generative math and 3D without needing traditional keyframe editing.

Claude is basically constructing the timeline programmatically.

But here's the part I think people are missing.

The best outputs aren't really coming from:
“Claude, make me a beautiful animation.”
The better creators are giving Claude something much closer to a motion-design specification.
Things like:
exact color palette

exact fonts

font weight

tracking

BPM

scene timestamps

animation timing

camera behavior

spring physics

motion blur rules

transition style

what happens on each beat
and even a list of things Claude is NOT allowed to use.
That's a huge difference.

For example, instead of:

“make a cool startup video”

you might tell it:

20 seconds.

120 BPM.

Background: #F5F3EE

Ink: #0A0A0A

Accent: #FF4D00

Display font: Syne ExtraBold.

UI font: Geist.

One idea per scene.

No particles.

No purple gradients.

No glassmorphism.

No futuristic HUD.

No random camera rotation.

Typography must land on downbeats.

Use closed-form springs.

Render at 60 FPS.

Use 4 subframes for motion blur.

Now you're directing the system instead of asking it to be creative for you.

And that seems to be the real difference between the crazy good examples and the obvious one-shot Claude demos.

Another thing I noticed:

good motion design is incredibly dependent on rhythm.

Some of these workflows literally start by choosing something like:

120 BPM

or

128 BPM.

At 120 BPM, one beat = 500ms.

Then your entire animation can be built around that timing grid.

Headline enters.

500ms.

Shape responds.

500ms.

Camera hits.

500ms.

UI changes.

500ms.

SFX hits.

Everything shares the same clock.

Some creators even use the same timeline data for BOTH the visuals and sound effects.

So instead of manually moving sound around later, the code already knows:

at 3.5s → whoosh
at 4.0s → impact
at 4.5s → UI click
at 5.0s → headline lockup

That synchronization is a big reason some of these clips feel much more expensive than the average AI animation.

And then there are springs.

A lot of the cleaner UI animations aren't just using:

ease-in-out

They're using actual spring equations.

Which means you can control:

mass

stiffness

damping

overshoot

velocity

And because the spring is mathematically calculated from time, you can render ANY frame independently.

That's important.

If frame 700 depends on what happened in frame 699, parallel rendering becomes painful.

But if frame 700 can be calculated directly from t, you can theoretically render different parts of the video simultaneously.

This is much closer to a rendering engine than a normal webpage animation.

Another technique I really liked:

per-glyph animation.

Instead of animating an entire headline as one object, Claude can animate every letter individually.

Each glyph can have its own:

Y position
opacity
blur
scale
rotation
delay

Then stagger them by something like 1/16 of a musical note.

That's how you get typography that feels designed instead of:

text appears → opacity 0 to 1.
There's also a really interesting UI style emerging.
One creator made basically ONE interface element that continuously transforms:
button
→ loader
→ success check
→ Dynamic Island
→ music player
→ slider
→ toggle
→ tabs
→ chart
→ command palette
→ notification
→ button again

No traditional cuts.

The same object keeps changing identity.

A cursor interacts with it throughout the video.

And the really clever part:

the leading edge and trailing edge of things like sliders or tab indicators can use DIFFERENT springs.

So when the indicator moves, the front moves first and the back catches up.

Tiny detail.

Huge difference visually.

Now compare all this with normal AI video generation.

Video models are incredible when you want:

cinematic environments

people

camera movement

realistic imagery

impossible scenes

But motion graphics have a different problem.

You need exactness.

If my product UI says:

10,799 tokens/sec

I need it to say exactly:

10,799 tokens/sec.

Not:

10,799
and then two frames later:
10,79B 😭
Same with typography.
Same with dashboards.
Same with charts.

Same with logos.

Same with buttons.

Code doesn't hallucinate your button into another button halfway through the shot.

Typography stays typography.

UI stays UI.

Numbers stay numbers.

And because it's code, everything stays editable.
But Claude already has its own visual clichés.
If you've been watching these videos you probably know exactly what I mean:
black background
orange/red circle
four corner brackets
“60 FPS”
“128 BPM”
giant kinetic text
particles
generative spirals
random geometry

and finally:

“EVERY FRAME WRITTEN IN CODE.”

The first few were crazy.

After seeing enough of them, you immediately know:

yeah Claude art-directed this one 😭

That's probably the biggest lesson from the trend.

The model can now execute motion design surprisingly well.

But taste still matters.

Maybe even MORE than before.

Because execution just became cheap.

If I were trying to make one of these today, I'd probably use:

Claude Code + Opus 5.5

HTML/CSS/JS for most 2D work

Canvas/SVG where needed

Three.js only when the shot actually needs 3D

a pure seek(t) timeline

Playwright for deterministic rendering

FFmpeg for frame assembly + motion blur + audio

60 FPS

120–128 BPM beat grid

2 fonts maximum

3–4 colors maximum

and I'd write all the actual copy BEFORE asking Claude to animate anything.

Then I'd do one really important step before rendering the full video:

render a still image at every major beat.

Basically create a contact sheet of the whole film.

Look at:

scene 1

scene 2

scene 3

scene 4

scene 5

all at once.

You'll immediately see:

bad typography

cramped layouts

weird hierarchy

inconsistent colors

random AI decisions

before spending time rendering hundreds of frames.

That seems like one of the highest-leverage parts of the workflow.

And I'd also explicitly ban:

random particle explosions

purple/blue AI gradients

glassmorphism everywhere

futuristic HUDs

brains

robots

neural-network graphics

unnecessary glowing objects

three different display fonts

and Claude congratulating itself at the end of the video 😂

Give the model constraints.

Don't give it complete artistic freedom.

The workflow basically becomes:

Write the idea.

↓

Write the actual copy.

↓

Choose your visual system.

↓

Pick BPM.

↓

Turn the story into timed scenes.

↓

Give Claude the motion rules.

↓

Claude builds the animation engine.

↓

Render one still for every important beat.

↓

Fix composition.

↓

Render every frame deterministically.

↓

Add subframe motion blur.

↓

Sync audio using the same timeline.

↓

FFmpeg → MP4.

That's the part of this trend I think is genuinely important.

This isn't just:

“AI can make cool videos now.”

We've had AI video for a while.

This is something different.

Motion graphics are becoming programmable through natural language.

And once the entire video exists as code, you can say:

“make the transition 300ms faster”

“replace that fake UI with our real dashboard”

“change every orange accent to our brand green”

“move the headline hit to beat 16”

“change the animation from 16:9 to 9:16”

“make the card become a 3D object”

“remove scene 4 and redistribute its time”

“make every spring 20% tighter”

and the system can modify the underlying animation instead of you manually rebuilding the timeline.

That's a completely different creative workflow.

The model isn't just generating the finished artifact anymore.

It's generating the system that produces the artifact.

And IMO that's the much bigger story behind all these Opus 5.5 videos.

[Disala Sennath @eapyk]

@iamvishal16_ios Yeah, I ended up doing the same thing. The clips look finished in the video, but once you actually see them in context, that’s when you realize how much time goes into tuning the spring and getting the motion to feel right.

[Disala Sennath @eapyk]

@AlexshevPm Yeah exactly. Seeing all the key frames together makes it way easier to spot pacing or hierarchy issues before wasting time on the full render.

[Disala Sennath @eapyk]

@Manthan86022060 That’s a really good tip. Exact spring values + BPM based timing probably make a huge difference in getting the motion to feel intentional instead of just “AI generated.”

[Disala Sennath @eapyk]

Really appreciated this video Chamath, especially the point about staying connected to the real world.

AI is moving so fast that if you spend too much time on X, tech circles, and AI communities, it can feel like everyone is already living in the future. Then you step outside that bubble and realize the real world is moving at a very different pace.

That gap is incredibly important to understand if you’re actually building products and businesses for real people.