I Asked GPT-6 Astra to Animate My Code. It Built This.

0:00 I started this experiment with a simple question. Could I describe a coding workflow and get an editable animation in After Effects? So, I gave Astra a straightforward idea to work with. Start

0:10 with a task, read the files, edit the code, and run a check. If the check fails, revise it, and try again. That was the whole story I wanted to explain. I kept changing the instructions as I

0:20 saw the results. First, the structure, then clearer movement, then sound. Eventually, I wanted to see how far I could push the visual style. Higsfield is sponsoring this video. Its AI motion

0:31 designer is a starting point for the experiment and these are a couple of examples Higsfield shared. I wanted to try an original developer idea of my own. Their setup starts with After

0:41 Effects installed, then connecting the Higsfield plugin in chat GPT and entering the use After Effects command. In my recording, I connected the plugin in the Codeex desktop app with GPT6

0:52 Astro selected. Here I open the plug-in page, install Higsfield, and finish the connection. Once that was connected, I opened the chat and described what I wanted to make. For the first attempt, I

1:03 asked for a static diagram and an animated version. I also specified orange and black rounded shapes, readable labels, and editable layers. The idea was deliberately simple. This

1:13 is an illustration of an agent workflow. The boxes explain a process. They aren't a recording of an agent fixing a real repository. I wanted something a developer could understand at a glance.

1:24 Notice what I put in that first prompt. There is a sequence, a visual style, and a request for an editable project. Those are three separate decisions. If I only say make an animation about coding, I

1:36 leave the actual story open. Here, the failed check gives the animation somewhere to go. And asking for separate layers gives me something useful to open afterwards. That is enough to start this

1:46 small experiment. The first render gave me the structure I asked for. You can follow the arrows through the steps, down to the failed check, and back around for a revision. There's already

1:55 some movement here, but the whole diagram is asking for your attention at once. The labels, the lower explanation, and the arrows are all competing. I wanted the active step to be much more

2:05 obvious. Let's follow that first version a little more slowly. The task comes in, the files are read, and then the code changes. The check is where the path splits. In this example, it fails. So,

2:16 we go down into the revision and come back to check again. That return arrow is doing useful work. It shows why a coding process can repeat. But to follow it comfortably, I need to know which

2:26 step I should be watching. So my next prompt was more specific. Show one active step at a time. Dim everything else, shorten the labels, and hold the failed check longer. I also asked it to

2:38 keep a copy of the original. Now the orange highlight tells you where to look. The rest of the diagram stays visible so you can still understand where the process goes next. It's the

2:46 same idea with clearer timing. The failure also gets room to register before the animation returns to the edit. That small pause matters. If the diagram moves on immediately, you can

2:57 miss why it went backwards in the first place. For the this is a useful way to write the next request. Instead of asking for more animation in general, I can point to the exact moment that feels

3:07 rushed. Here it is the failed check. Keep that visible. Let me notice it. Then carry me back to the edit. The orange highlight gives the sequence a clear focus. The other boxes stay

3:18 dimmed, which leaves the shape of the workflow on screen while each step takes its turn. Third try, I asked for sound effects and less text. I didn't need another slogan underneath a diagram that

3:28 already explains itself. I wanted the picture to carry more of the explanation. The project gained separate audio layers and the repeated status text came out. The title became shorter,

3:39 too. You can see the animation has more space around it now. >> [snorts] [snorts] >> This was getting clearer, but I was

4:09 still looking at a flowchart. At that point, I wanted to try a different kind of animation. Something that felt like a little film about coding. For the fourth attempt, I described the shots. Start

4:19 with big fix this bug topography, move into floating code panels, show a failed test, revise the code, and finish on cloud codes. I kept the orange, black, and cream palette. But this time, I

4:30 asked for depth, masks, camera movement, and transitions between scenes. I was giving it a sequence to build rather than just the contents of a diagram. Here's that version. The opening letters

4:41 assemble and the code window becomes the main subject. Then the test result takes over. Each part has its own moment instead of sharing the screen from the beginning. The little code example is

4:51 about a zero quantity being treated as a default value. The film shows a failed check, an edit, and a passing result. It's an illustrative developer story, so those results belong to the animation.

5:03 Back inside After Effects, the compositions and layers are still there. That's the part I care about, keeping a project I can revise. The render is useful, but the editable timeline is

5:13 what lets the experiment continue. There is a specific little bug behind those code panels. The quantity is zero, but the original expression replaces it with one. That makes a total of 20 appear

5:24 where the test expects zero. The revision changes the fallback so that zero stays a valid quantity. Now, the passing test has a reason to appear. I like having that tiny story underneath

5:34 the animation. Even with the camera movement and the big type, there is something concrete for a developer to follow from one shot to the next. For the second experiment, I changed the

5:44 idea more completely. I wanted a short motion graphics piece built around three words: idea, code, ship. A sketch becomes a laptop, then the laptop becomes a rocket. The prompt asked for

5:55 layered collage, paper texture, bold type, and smooth transitions. I also asked for original supporting assets were needed. This time the visual treatment was part of the brief from the

6:05 start. An original cream paper texture was generated through Higsfield. That became the backdrop for the piece. The laptop, rocket, text, and animation were then built as native After Effects

6:15 layers. The paper image has a pretty small job here. It gives the scene that textured surface. The words and the objects still need to sit above it as separate parts. That gives me a surface

6:26 to build on without committing the whole scene to one picture. The generated image is one ingredient in the project. While the timing, the shapes, and the transitions make it into a film. The

6:36 first attempt at this part got interrupted when I accidentally stopped computer use. There was also a bridge connection problem. I sent the request again and continued the build from the

6:46 saved work. One detail to keep clear, the Higsfield AE bridge remained unavailable in that chat. The final film was completed through native After Effects scripting. That's how this

6:56 particular run reached the result you're about to see. And this is the new direction. We start with the sketch on paper, move into the laptop and its code, then turn that shape into the

7:05 launch. The orange scene gives the rocket its own space. The exhaust fills the frame and leads into the cloud code's ending. I like that the transition belongs to the subject. It

7:15 comes from the launch itself. The ending also has a moment to settle. The project separates the sketch. the code scene, the hero shapes, and the ending. The paper texture is a linked image. The

7:26 lettering and the drawn objects remain separate, so they aren't baked into that background. That gives me useful places to make the next change. If the title needs different wording or a scene needs

7:36 longer on screen, I have an actual composition to work with. I don't have to treat the exported video as the only thing I own. Say I wanted to change the ending for another project. I would

7:46 start with the ending composition and its text layers. If the words became longer, I would check their size and spacing, then watch the transition into that scene again. A small text change

7:56 can affect how long somebody needs to read it. That is the kind of revision I mean when I ask for an edible file. I want to be able to inspect one part and see how it fits with the rest. I asked

8:06 for sound on this version, too. The first sound pass felt harsh to me, so I asked for something softer and quieter. The later project keeps the sound files separately as well.

8:47 What changed most across these attempts was my brief. I went from naming the steps to explaining the timing, then the scenes, and finally the visual style. Each result helped me decide what to ask

8:57 for next. For a developer channel, I can see myself using this process for a short workflow explainer or an intro to something I've built. I would still watch the whole render and check whether

9:08 the transitions actually help the explanation. For example, if I were explaining a feature in a project, I would start with the question a viewer has. What happens when I press this

9:18 button? Then I could show the input, the step that changes it, and the result. That gives me a small sequence to describe to Astra. Once the structure makes sense, I can decide whether it

9:29 needs a diagram, a code panel, or a more playful transition. The animation should help that explanation land. Higsfield says the AE plugin is free to use with your existing chat GPT subscription.

9:40 Credits are spent on generation features. After effects itself has its own Adobe subscription. I've put the starting link in the description. If you try it, start with one idea you can

9:50 explain clearly, then revise what you actually see. That's what made this experiment interesting for me. Which direction would you use? The coding film or idea code ship.