Claude Scripting ExtendScript for After Effects Automation

Claude scripting for After Effects is a practical way to remove repetitive production work while leaving motion-design judgment to the designer. It generates ExtendScript and runs it through either an in-app panel or a command-line agent. The right route depends on where the work happens, how much setup the designer accepts, and whether the job stops at an open composition or extends into a production pipeline.

What Claude scripting for After Effects actually does

Claude turns plain-English requests into ExtendScript files with the.jsx extension. Through an integration, those scripts execute against a live After Effects project and perform actions a designer would otherwise do by hand. The mechanism is code generation followed by execution. It is not evidence that Claude understands the artwork or knows what a finished animation should feel like.

That mechanism suits jobs with clear, repeatable instructions, including renaming layers in bulk, offsetting keyframes, applying expressions across compositions, auditing project health, and batch-rendering. These jobs are repetitive, but still demand precision. Code can apply an expression across compositions when asked, but judging whether the movement works takes a different kind of judgment.

The two integration routes put that operation in different working environments. A CEP panel embeds the exchange inside After Effects, while a code-agent skill operates from the command line. They are not interchangeable ways to open the same interface. The choice changes how the agent gets project context, runs scripts, and fits into the rest of the production workflow.

Why ExtendScript's ES3 constraint shapes every script Claude generates

ExtendScript’s ES3 constraint comes before any choice of tool. Claude must be told to write ES3-compliant code and use var and string concatenation throughout. For example, using modern scripting syntax to make a string instead of ES3 string concatenation can cause the script to fail silently and leave the requested task undone.

The TerminalSkills After Effects skill keeps ES3 constraints and API patterns in its SKILL.md so the agent reads them before it writes code. The aedev-tools skill does the same through rules/extendscript-fundamentals.md, which it reads before it writes a mutation script. Both treat compatibility as a prerequisite to changing the project. That is the useful distinction between asking a general model for scripting code and giving an agent the rules of the environment where its code must run.

How the Claude Scripter CEP panel works inside After Effects

Claude Scripter places the prompt-and-run workflow inside After Effects. A designer types a sentence into the CEP panel, the panel generates ExtendScript, and the script runs natively in the open project. There is no application switch in that loop. The output is visible in the composition in real time, which makes the panel a low-friction entry point for individual scripting tasks.

The interface also avoids a separate agent environment. There is no terminal to work through and no permission configuration beyond what After Effects already exposes. For a designer who wants to make a change and inspect it immediately, that keeps the interaction close to the work. The designer stays in the application where the result will be judged.

The aescripts.com listing identifies Claude Scripter as a commercial panel available through its standard distribution channel. The panel offers a familiar place to request an operation. That makes it especially suitable when the immediate need is to automate a task in the composition already open.

How the aedev-tools code-agent skill automates After Effects from the command line

The aedev-tools skill takes the work outside the panel, but it has a hard platform limit. It runs on macOS only, with After Effects open. It generates JSX and executes it through osascript, so the designer does not need to use the application’s own interface to trigger a script. Hands-free execution comes with a more demanding setup.

The skill follows three stages rather than moving straight from a prompt to a project change. It first gathers context silently through background query scripts that do not steal focus from After Effects. It then loads domain knowledge from rule files. Finally, it generates and executes the script, or asks for confirmation before execution, depending on the risk level of the mutation. Every mutation is wrapped in an undo group, allowing the designer to reverse an agent action with a single Cmd-Z.

The bundle contains 53 files, including 41 JSX scripts covering layers, keyframes, expressions, rendering, font inventory, expression error scanning, and full project audits. Its query scripts write results to /tmp/ae-assistant-result.json. That location is fixed and shared across projects. It is therefore a relevant constraint when considering concurrent projects.

The osascript grant is a wildcard that extends beyond After Effects. That is the security trade-off attached to this hands-free route. It belongs in the decision about using the skill.

What the TerminalSkills After Effects skill adds for pipeline-oriented work

The TerminalSkills skill extends the code-agent approach into work beyond the open project. It covers programmatic project manipulation with ExtendScript, CEP panel development, procedural animation expressions, MOGRT template automation, and data-driven graphics. Its scope also includes production pipeline integration. This makes it relevant when scripting must connect project work to a broader production process rather than end with a visible change in a composition.

Rendering is a concrete example of that broader reach. The skill covers the aerender CLI for headless batch rendering, and aerender enables render-only machines to process compositions without a signed-in After Effects license. That supports studios using dedicated render nodes.

For teams that work with pipelines, MOGRT automation, data-driven graphics, and CI/CD integration call for different tools than an in-app prompt panel. The skill has the domain knowledge for that work, while the panel lets designers work directly inside After Effects.

Which tasks Claude scripting handles well and which it cannot replace

Claude scripting works best when the task can be laid out in clear steps. Bulk renaming, keyframe offsets, expression management, and project audits fit because the requested operation can be expressed in code. Repetition is where scripting earns its place. The designer supplies the intended change, and the agent handles the production steps needed to apply it.

That usefulness does not extend to judging the artwork. Claude cannot look at artwork and understand it or judge whether motion feels right, and writing scripts does not give it the spatial and structural reasoning needed for intelligent character rigging. Specialized rigging tools serve a different purpose. Generating code that changes a character is not the same as understanding how that character should be rigged.

Execution feedback has the same boundary. MCP tool calls can confirm that a script executed without error, while computer-use approaches can confirm that a button was clicked. Neither establishes that the output motion is correct. Designer review after every agent action is therefore a required part of the workflow.

A documented attempt with the Kumo Productions MCP shows what can go wrong before a script runs. Its open-source After Effects MCP, published on GitHub, lets Claude Code open a project, create compositions, layers, keyframes, effects, and text, and render. The attempt revealed that the transcript could get proper names and terminology wrong. Those errors had to be fixed before building, or the wrong wording would be written into the project.

A naming problem in the skills catalog that wastes real time

Two skills in the catalog have the slug after-effects but do different jobs. The aedev-tools entry generates and executes ExtendScript against a live After Effects installation on macOS. The dylantarre entry writes no automation at all. Instead, it converts Disney’s 12 animation principles into frame counts, timing tables, and ready-to-paste expressions.

As of October 20, 2026, the dylantarre skill has more installs than the aedev-tools skill. The more-installed option is therefore the one that never opens After Effects. A third catalog entry adds confusion by indexing the same aedev-tools bundle under the repository’s old name, creating another row for that automation route.

The dylantarre skill still answers a useful question about what an animation’s timing should be. Translating subjective words into concrete frame counts produces structured output an agent can apply without another round of prompting. Check what a skill actually executes before installing it, rather than treating its name or install ranking as a description of its behavior.

How persistent project memory turns a one-off script into a repeatable studio workflow

A one-off script solves the operation in front of the designer. Repeatable studio work also depends on retaining the conventions behind that operation, including naming conventions for project elements, brand constraints, expression preferences, and script habits. Claude’s 200K+ token context window can hold an entire codebase or project reference library. That makes a request to reuse a client’s naming conventions realistic when the relevant material is in context.

Compartmentalized project memory isolates memory banks by project folder, so one client’s naming conventions and brand constraints do not bleed into another client’s work. Without that distinction, retaining more information is not the same as retaining the right information for the current project.

For teams, the same setup lets each artist keep a separate memory of their preferences for expression syntax and their scripting habits. The agent can adapt to the individual workflow.

Voyager extends that persistent-memory model across the creative toolchain. Its adaptive workflow memory personalizes to each user across sessions, while its multi-model architecture separates planning and direction from asset generation. A team can use Claude or other frontier models as the agent for planning creative work, with separate generation models producing images, video, voice, and music upstream. This setup lets teams work with more than one provider and change how their tools fit together.

Choosing the right approach for the work in front of you

For designers who want to stay inside After Effects, Claude Scripter is the starting point. The panel suits designers on any OS who need to see the results of each script right away without setting up a terminal environment. Choose it for that short feedback loop. Its advantage is the direct path from a request to an inspectable change in the open composition.

For macOS users seeking hands-free batch operations, project audits, or expression management, aedev-tools is the more suitable route. That choice assumes comfort with the osascript wildcard grant and the fixed temporary result path. When the job instead extends into render pipelines, MOGRT automation, data-driven graphics, or CI/CD integration, the TerminalSkills skill fits the broader scope.

Before the first script runs, two setup requirements apply across these routes. Enable “Allow Scripts to Write Files and Access Network” in After Effects preferences, and explicitly require ES3 compliance in every prompt that generates code. Compatibility is not something to leave implicit. After execution, review every output, because a successful script run cannot establish that the motion is correct.