Claude and friends aren't making our jobs easier. They're changing what our jobs are.
Walt Disney didn't just move animation to the big screen. He invented a system for scaling creative work. Senior animators drew the keyframes: the frames that defined the motion, the emotion, the story. They incorporated staging, anticipation, timing, exaggeration, and the other principles of animation Disney had documented. These were the frames that mattered.
Between the keyframes, a team of "tweeners" filled in the space. The tweeners did the heavy lifting. But the quality of the final product lived or died on the quality of the keyframes.
We're living that same shift right now.
The Tweeners Are Here
AI agents are the best tweeners we've ever had. They can fill in enormous amounts of space between our decisions: scaffold a module, wire up an API, write tests against a spec, refactor a pattern across a codebase. They're fast, they're tireless, and they're getting better every month.
That's the part the YouTube shorts get right. The part they skip is what happens when the keyframes are wrong.
When the tweeners do the heavy lifting, the keyframes have to be right. A bad keyframe doesn't just produce one bad drawing. It sends every frame between it and the next keyframe in the wrong direction. The more productive the tweeners are, the more damage a bad keyframe does.
Software works the same way. A wrong architectural decision, a misunderstood domain boundary, a data model that doesn't fit the problem: these are bad keyframes. And when agents can generate thousands of lines of code from a single prompt, a bad keyframe propagates faster and further than it ever could when we were writing every line by hand.
Our Jobs Got Harder
AI didn't hand us a vacation. It handed us a promotion.
When we were writing all the code ourselves, a bad decision affected one file, one module, maybe one sprint. We'd notice it in the writing, often before we even committed. The slowness of manual implementation was a natural brake on bad ideas.
That brake is gone. Agents implement at the speed of tokens, not keystrokes. A poorly conceived abstraction becomes a fully built system before we've finished our coffee. And now we own it. We own the decision and the consequences at scale.
I've felt this firsthand. It's uncomfortable. When an agent ships something that doesn't work, I can't blame the agent. The agent did exactly what I asked. The keyframe was wrong. I was wrong, and now I have to own that in a way that's harder to hide behind busy work.
The answer isn't to micromanage. Having fifty 1:1 conversations with fifty agents doesn't scale any better than writing all the code ourselves. What scales is investing in the keyframes: just enough planning to set the direction, captured somewhere the whole team can see it, before the tweeners start filling in the space.
Better Software, Not More
The old job was: write code, ship features, stay busy. The new job is: make the decisions that matter, and make them well.
That means understanding the domain deeply enough to draw the right keyframes. It means knowing which architectural principles apply and which ones are ceremony. It means reviewing what comes back from the tweeners with enough context to spot when a keyframe sent things sideways.
Disney's keyframers didn't just draw well. They understood motion, weight, emotion, story. The drawing was the output; the understanding was the job. The best keyframers weren't the fastest artists. They were the ones who knew which frames mattered and why.
We're on the hook to deliver better software now. Not more software. Not faster software. Better software. Because for the first time, the bottleneck isn't implementation. It's judgment.
The Principles Matter More Than Ever
Disney documented his principles of animation because they were the difference between keyframes that worked and keyframes that didn't. We have our own principles: separation of concerns, clear domain boundaries, appropriate abstraction, meaningful naming, testability.
These aren't academic exercises anymore. They're the keyframes. When agents generate the in-between, our principles are the only things keeping the output coherent. Skip the principles, and the tweeners fill the space between bad decisions with confident, well-formatted, utterly wrong code.
The good news is that keyframes, once drawn well, compound. When our planning decisions live in real issues on a real board, and our agents automatically capture what they learned, what they decided, and why, that context doesn't vanish when the PR merges. It becomes institutional knowledge. The next keyframe gets drawn with the benefit of every one that came before it. That's how we built Cate: just enough planning to set direction, just enough automated context capture to make every keyframe better than the last, and then get out of the way so the tweeners can do what they do best.
The developers who thrive in this new world will be the ones who take their craft more seriously, not less. The keyframes have to be right. And that's on us.
Let's add "just enough" planning to your AI workflow. Request early access to Cate, or get in touch. We'd love to hear how your team works.