Use Claude with creative MCP connectors in production

Creative connectors matter because they move Claude from "person in the chat who gives advice" to "assistant that can act inside the tools where the work already lives." Anthropic's April 28, 2026 Claude for Creative Work announcement named nine connectors: Ableton, Adobe for creativity, Affinity by Canva, Autodesk Fusion, Blender, Resolume Arena, Resolume Wire, SketchUp, and Splice.[^anthropic] The same launch made MCP concrete for creative professionals: Blender scenes, Adobe assets, Ableton workflows, 3D design handoffs, and sample search are easier to understand than another abstract enterprise integration.

The production lesson is not "let Claude make the art." The lesson is "use Claude as a workflow layer around creative software." Anthropic says Claude can help with learning tools, extending tools with code, bridging tools in a pipeline, rapid exploration, and repetitive production work.[^anthropic] Those are real production jobs, but none of them replaces taste, brief interpretation, brand judgment, rights review, or final sign-off. MCP gives the assistant a structured way to reach tools; it does not make the assistant the creative director.

If you have already taken [[courses/mcp-from-first-principles-to-production/01-why-mcp-exists]], think of this chapter as the creative-studio version of the same idea. If you came from [[courses/claude-tool-use-from-zero/07-creative-connectors]], this course slows down the workflow design so you can use connectors safely across a team, not just demo them once. For vocabulary, keep [[glossary/mcp]] open as you read.

Separate advice from action

Claude can help a creative project in two different modes.

In advice mode, Claude reasons from the context you provide. You might paste a campaign brief and ask for storyboard options. You might ask it to explain why a Blender modifier stack is behaving oddly. You might describe an Ableton routing problem and ask for a troubleshooting checklist. Nothing changes in your project unless you manually apply the advice.

In action mode, Claude can call a connector-exposed tool. MCP describes tools as server-exposed functions that a language model can invoke with structured inputs.[^mcp-tools] A creative connector can therefore become a controlled action surface: inspect a scene, call a Python API, search a sample library, generate an export plan, or apply a batch operation. The tool call is the boundary where the workflow becomes operational.

That boundary is useful only if the human can see it. The MCP tool specification explicitly recommends clear tool exposure, visible invocation indicators, and confirmation prompts for operations so a human can remain in the loop.[^mcp-tools] In a creative studio, this is not just a security recommendation. It is how you preserve taste and accountability. A hidden connector call can change layers, rename files, overwrite exports, or create a derivative asset whose rights need review.

Use this rule for the rest of the course:

• Advice mode is for interpretation, options, explanation, and review.
• Action mode is for bounded changes through a named connector.
• Approval mode is for taste, rights, brand fit, destructive edits, and final delivery.

- Advice mode and action mode are distinct: advice changes nothing in your project; action mode triggers a connector tool call that can modify external systems.
- Human approval covers taste, rights, brand fit, destructive edits, and final delivery — these are never delegated to the connector.
- The MCP tool specification recommends visible invocation indicators and confirmation prompts so humans remain in the loop on every connector action.

Map the creative stack before you prompt

MCP is an open standard for connecting AI applications to external systems such as data sources, tools, and workflows.[^mcp-intro] In creative work, those systems are not just APIs. They include live project state, files on disk, app-specific histories, layers, timelines, material graphs, sample libraries, export queues, and human review rituals.

A useful creative MCP map has five parts.

Host: The AI application where the user talks to Claude. The host manages the conversation and decides how tool results are shown.

Connector or MCP server: The bridge to a specific tool or service. Anthropic says the Blender connector is built on MCP and exposes a natural-language route to Blender's Python API.[^anthropic] Other connectors may be more documentation-oriented, library-oriented, or product-specific.

Tool: A callable operation. In Blender, that might inspect objects or run Python. In a sample-search workflow, it might query a library. In a documentation workflow, it might retrieve grounded help.

Resource: The thing being read or changed. This could be a .blend scene, a layered design file, an audio project, an exported still, a sample result, or official product documentation.

Checkpoint: The human or system review step after the tool call. This is where you compare the result to the brief, inspect diffs where possible, confirm licensing, or decide whether to roll back.

The most common mistake is to write prompts that skip straight from the brief to action: "make this scene feel premium" or "create campaign assets for this launch." Those instructions hide too many decisions. The connector might need to infer style, scope, asset rights, output dimensions, and allowed edits. A better prompt turns the work into a bounded tool call plus a review plan.

Brief: Create a 10-second product-launch visual loop for a premium desk lamp. The team may use Blender for a simple 3D scene and Adobe for creativity for still/video finishing. The final approval must stay with the creative director.

Create a workflow map with five columns: host, connector/server, tool action, resource/file state, checkpoint. Do not propose destructive edits. Mark any live connector outputs as TODO: verify with QA.} expectedOutput={A table with advice steps first, then bounded connector actions such as inspecting a Blender scene, drafting a non-destructive scene-change script, preparing export variants, and documenting checkpoints. Live app results should be marked "TODO: verify with QA" because the prompt has not actually run against Blender or Adobe.`} />

- A useful creative MCP map has five named parts: host, connector/server, tool, resource, and checkpoint — map these before writing any prompt.
- Prompts that skip from brief to action hide too many decisions; a production prompt turns work into a bounded tool call plus an explicit review plan.
- The most common mistake is writing a prompt like "make this scene feel premium" that forces the connector to infer style, scope, rights, and output dimensions without guidance.

Keep the file state visible

Creative work fails quietly when file state is vague. "Update the scene" is not a production instruction. "On a duplicate of lamp_loop_v03.blend, add a temporary area light named AI_TEST_softbox_01, do not delete existing lights, return a summary of changed objects before I save" is a production instruction.

The difference is state.

File state answers these questions:

• What is the current working file?
• Is the connector allowed to read only, write to a duplicate, or modify the active file?
• Which objects, layers, tracks, comps, or exports are in scope?
• What naming convention should identify AI-assisted changes?
• What should be returned before the human commits the change?

Anthropic's Blender section is a useful example because it names the Python API as the automation layer.[^anthropic] Blender's own current API documentation describes the Python API as the scripting interface used to access and manipulate Blender data and operations.[^blender-api] That is powerful, but it also means a tool call can touch scene data at a low level. The safest first workflow is read-only inspection, then generated script review, then execution on a duplicate or versioned copy.

The same pattern applies outside Blender. Adobe for creativity workflows often depend on layers, source assets, export presets, and review notes. Ableton workflows depend on Live set version, routing, devices, automation lanes, clips, and export settings; the dated Ableton Live 12 reference manual is the right grounding source when a workflow question depends on product behavior.[^ableton-manual] Splice workflows depend on sample search, licensing assumptions, and whether a sample has been downloaded or placed into a project; Splice's licensing FAQ is the kind of source a team should check before treating a sample as campaign-ready.[^splice-license] The connector changes, but the file-state questions remain the same.

- File state answers five questions before any connector call: current file, read vs. write permission, objects in scope, naming convention for AI changes, and what must be returned before saving.
- Blender's connector exposes Blender's Python API; read-only inspection followed by script review before execution on a duplicate file is the safest first workflow.
- The same file-state discipline applies across all creative tools: Adobe layers, Ableton Live sets, Splice sample licensing, and SketchUp scenes.

Put the human decisions in the prompt

Human-in-the-loop design is often discussed as a safety feature. In creative work, it is also the source of quality. Claude can accelerate exploration, but it cannot know the client's unstated taste, the studio's tolerance for visual risk, or the licensing constraints around a campaign unless the human supplies and enforces those constraints.

The best prompts say what Claude may decide and what it may not decide.

Claude may decide:

• how to turn a clear instruction into a script draft;
• how to inspect a scene and summarize likely issues;
• how to generate a checklist from official documentation;
• how to propose export variants;
• how to organize repetitive production tasks.

Claude may not decide:

• whether the final asset is on brand;
• whether a licensed source can be used commercially;
• whether a destructive edit is acceptable;
• whether a generated result is legally or ethically safe to ship;
• whether to overwrite a source file.

This is especially important because Anthropic presents connectors as a way for Claude to work alongside professional creative software, not as a replacement for creative professionals.[^anthropic] The course will keep that line throughout: Claude can help execute and explain; humans own direction and release.

Unsafe prompt: "Open my Blender scene and make the product look more cinematic. Then export a preview."

Constraints: - Claude may inspect the scene and propose changes. - Claude may draft Python but must not execute it until reviewed. - Any export must come from a duplicate file. - The creative director approves final look. - Mark any app-specific result as TODO: verify with QA.} expectedOutput={A safer prompt that asks Claude to inspect the scene first, summarize current lighting/camera/material state, propose 2-3 non-destructive changes, draft Python with comments, wait for approval before execution, use a duplicate file for exports, and mark live results as TODO: verify with QA.`} />

- Prompts that state what Claude may and may not decide are safer and more reliable than open-ended action prompts — Claude can execute bounded tasks but should not own taste or rights decisions.
- Script drafting without execution and file duplication before exports are the two safest defaults for any creative connector workflow.
- Anthropic positions connectors as a way for Claude to work alongside professional creative software, not as a replacement for creative professionals.

Use checkpoints as your production control system

A checkpoint is a deliberate pause after an assistant action. It can be as simple as "show me the generated script before running it" or as formal as a creative director review with a versioned approval note. Without checkpoints, a connector workflow becomes a chain of invisible assumptions.

For this course, every connector workflow will use the same checkpoint pattern:

1. Brief checkpoint: What outcome are we trying to produce?
2. Scope checkpoint: Which files and tool actions are allowed?
3. Preview checkpoint: What does Claude think it will change?
4. Execution checkpoint: Did the connector do only the approved work?
5. Review checkpoint: Does the result satisfy taste, rights, and delivery constraints?
6. Rollback checkpoint: Can we return to the previous version?

The MCP docs make this pattern easier to justify because tool calls are explicit protocol events, not vague conversational magic.[^mcp-tools] Claude's tool-use documentation also distinguishes the model's reasoning loop from tool interactions: the model can request tool use, receive results, and continue with the returned context.[^claude-tools] In production, you should treat each result as evidence to inspect, not as proof that the work is done.

Build your first connector-safe workflow

Before you use any specific connector, practice writing the workflow shell. You can reuse this template for Blender, Adobe, Ableton, SketchUp, Fusion, Resolume, or Splice:

```md Creative brief:

Current file or project state:

Connector to use:

Allowed tool actions:

Forbidden actions:

Claude should first inspect or explain:

Claude may draft:

Claude must ask before:

Expected returned evidence:

Human checkpoint:

Rollback path: ```

Here is the mindset shift: you are not asking Claude to "do creative work." You are designing a small operating procedure for a creative task. The connector gives Claude a hand inside the software, but the prompt gives that hand a boundary.

In the next chapter, we will apply this pattern to Blender. Blender is the clearest first case because Anthropic explicitly describes its connector as MCP-based and tied to Blender's Python API.[^anthropic] That lets us see the full stack: natural language, tool call, generated script, scene state, review checkpoint, and rollback.

[^anthropic]: Anthropic, "Claude for Creative Work," 2026-04-28, updated 2026-05-01, retrieved 2026-05-27, https://www.anthropic.com/news/claude-for-creative-work?lang=us [^mcp-intro]: Model Context Protocol documentation, "What is the Model Context Protocol (MCP)?", retrieved 2026-05-27, https://modelcontextprotocol.io/docs/getting-started/intro [^mcp-tools]: Model Context Protocol specification, "Tools," version 2025-06-18, retrieved 2026-05-27, https://modelcontextprotocol.io/specification/2025-06-18/server/tools [^claude-tools]: Anthropic Claude docs, "Tool use with Claude," retrieved 2026-05-27, https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview [^blender-api]: Blender Python API documentation, current branch, retrieved 2026-05-27, https://docs.blender.org/api/current/ [^ableton-manual]: Ableton, "Live 12 Reference Manual," PDF path dated 2026-03-20, retrieved 2026-05-27, https://cdn-resources.ableton.com/resources/pdfs/live-manual/12/2026-03-20/live12-manual-en.pdf [^splice-license]: Splice Support, "Splice Sounds Licensing FAQ," retrieved 2026-05-27, https://support.splice.com/hc/en-us/articles/360025013734-Splice-Sounds-Licensing-FAQ

Blender's connector is different from the other Claude for Creative Work connectors because Anthropic explicitly calls out the Python API as the integration surface.[^anthropic] Every UI action in Blender maps to a Python call, which means the connector can reach almost anything in a scene — objects, materials, modifiers, node trees, export settings, and render parameters. That power is the reason you need to stay close to the Python layer, not abstract away from it.

This chapter teaches you to use Claude's Blender connector in a way that keeps the generated script visible, reviewable, and bounded. You write a clear prompt, Claude produces a bpy script, you read the script before you run it, and you verify the scene after. None of that is harder than reviewing a macro before you run it — but skipping any step is how a connector session silently damages a production .blend file.

For MCP vocabulary (host, connector, tool, resource), see [[courses/claude-tool-use-from-zero/03-building-your-first-mcp-server]] and [[glossary/mcp]]. This chapter assumes you can open Blender's Scripting workspace and identify the active object. No prior Python experience is required.

Why the Python API is the connector surface

Blender exposes its entire feature set through a single Python module called bpy.[^blender] When you click "Subdivide" in the mesh menu, Blender internally calls something equivalent to bpy.ops.mesh.subdivide(). When you parent one object to another, it sets bpy.context.object.parent. Every UI action has a Python equivalent, and the Blender connector gives Claude access to that layer.[^blendermanual]

There are three sub-namespaces you will see in generated scripts:

• `bpy.context` — the current state: active object, selected objects, active scene, edit mode.
• `bpy.data` — the data store: every mesh, material, image, text, collection, and scene in the file.
• `bpy.ops` — operators: the callable equivalents of menu commands like "Add Object" or "Apply Modifier."[^bpyops]

Operators (bpy.ops) behave like UI actions. They read from bpy.context to know what to act on. That is why a generated script might call bpy.ops.object.modifier_apply(modifier="Subdivision") — it applies the modifier to whatever object is active at the time the script runs. If the wrong object is active when you run the script, you apply a modifier to the wrong mesh. This is the most common source of connector mistakes, and reading the script first catches it every time.

Anthropic says the Blender connector can help with learning tools, writing scripts and plugins, accessing Blender's documentation, rapid exploration, and repetitive production work.[^anthropic] All five use cases go through the Python layer. "Rapid exploration" means generating a bpy loop that duplicates objects to test a lighting rig; "repetitive production work" means batching the same material assignment across thirty scene objects. In both cases the connector produces Python that runs inside your local Blender process — which is why the script must be readable to you before it executes.

Write a bounded scene-edit prompt

A bounded prompt names the file, the object, the desired change, and the verification step. Vague prompts produce scripts that guess at context; bounded prompts produce scripts that target exactly what you described.

Use this structure:

Scene: <file name or scene name>
Target object: <exact object name as it appears in the Outliner>
Change: <specific action in concrete terms>
Verification: <what I will check after the script runs>
Do not: <known side effects to avoid>

The "Do not" line is the most valuable field. It tells Claude what you already know about your scene: which objects share materials, which modifiers must not be applied, which collections are referenced by other scenes. Claude cannot inspect your .blend file without that context, so naming your constraints prevents the script from touching shared data blocks you did not intend.

A Python script using bpy.ops.object.modifier_add(type='SOLIDIFY') followed by property assignment on the modifier. The script should reference the object by explicit name (bpy.data.objects['Logo_Plane']), not by active selection (bpy.context.object). Expected Claude behavior; verify against your connector version.

The connector translates that prompt into a bpy script. Before you run it, open Blender's Scripting workspace, paste the script, and read it. A well-bounded prompt produces a script of fewer than twenty lines that you can check in under two minutes.

Review generated Python before execution

Script review is not optional for production work. Blender's undo history (Ctrl+Z) lets you reverse most script runs, but some operations are not reliably reversible: applying modifiers collapses them into the base mesh, joining objects merges their data blocks, and deleting data that has no other users removes it from the file permanently. These cannot be undone without reloading from a saved file.

The MCP specification notes that tools should provide visible invocation indicators and support confirmation prompts so humans remain in control of each tool action.[^mcp] The Claude tool-use documentation similarly describes the model requesting tool use, receiving results, and continuing reasoning — meaning each connector action produces traceable side effects that must be confirmed before they run.[^tooluse] In Blender, reading the script is your confirmation step.

Use this checklist on every generated script before executing it:

1. Object target — Does the script reference the object by explicit name (bpy.data.objects['Name']) or by active context (bpy.context.object)? Context-dependent scripts act on whichever object is selected at run time.
2. Modifier application — Does the script call modifier_apply()? If you did not ask for it, delete that line.
3. Shared data blocks — Does the script reassign a material that could be shared across other objects? Check material.users in the Properties panel before the session.
4. External file references — Does the script pack, unpack, or relink an image, audio file, or library? External references affect every collaborator who opens the file.
5. Mode dependency — Does the script require Edit Mode or Object Mode? A missing bpy.ops.object.mode_set(mode='OBJECT') line raises an error if you are in the wrong mode when you run it.
6. Error handling — Does the script check whether the named object exists before acting? Without if 'Logo_Plane' in bpy.data.objects:, a missing object throws a KeyError and leaves the script half-executed.

Script: import bpy

obj = bpy.context.object bpy.ops.object.modifier_add(type='SOLIDIFY') obj.modifiers['Solidify'].thickness = 0.05 obj.modifiers['Solidify'].offset = 1.0 obj.modifiers['Solidify'].use_rim = True" expectedOutput="Flag line 3: 'bpy.context.object' targets whatever object is currently active in the scene, not a named object. Recommendation: replace with bpy.data.objects['<your object name>']. No modifier_apply, join, delete, or external file-path calls detected. Material not modified. The script is otherwise safe to run after fixing the context reference on line 3." />

Protect production files with versioned copies

Before any Claude connector session on a production asset, save a versioned copy. Name it with a _preAI suffix and today's date:

product_v03.blend                         ← current working file
product_v03_preAI_2026-06-14.blend       ← copy made before the connector session

Blender's incremental auto-save, found under Preferences > Save & Load > Auto Save, writes to a temp directory every few minutes and survives script crashes. Set the interval to 2 minutes and the count to 10 for connector sessions. Auto-save is a crash recovery layer; the explicit versioned copy is your deliberate safety checkpoint before you start asking Claude to modify the scene.

Non-destructive edits — modifier stacks, node trees, shape keys — are safer than operators that apply or merge data. Where possible, ask Claude to add modifiers instead of applying them, set driver values instead of baking animations, and append materials instead of replacing existing slots. Blender's modifier stack is designed for iterative, non-destructive work;[^blender] a connector session that respects the stack leaves your production file easier to change and audit after the session ends.

Practice: add a labeled procedural object

Open a new Blender file with the default cube. Write a bounded prompt that asks Claude to add a UV sphere as a labeled procedural reference object — a scale marker you would use in a production scene, not a final asset.

Your prompt must include:

1. The scene context: default Blender scene, Object Mode
2. The target: a new UV sphere — not the existing Cube
3. The desired properties: radius 0.5 m, location (2, 0, 0), renamed to "ScaleRef_Sphere"
4. The verification step: the sphere appears in the Outliner at the correct world location
5. A "do not" clause: do not modify the default Cube or its material

After Claude returns a script, run through the six-point checklist from the previous section. Pay attention to whether the rename uses bpy.context.object.name = (safe immediately after add, because the new object becomes active) or bpy.data.objects['Sphere'].name = (explicit reference). Both patterns can be correct in this case — understanding why is the difference between using the connector and depending on it.

Run the verified script, confirm the sphere in the Outliner, and then check its world location with Object > Item panel (N key) > Location. That two-step loop — bounded prompt, reviewed script, verified result — is the same pattern you will use for every Blender connector action in production.

In the next chapter, the pattern carries into [[courses/claude-mcp-mastery/03-use-adobe-creative-cloud-connectors-as-production-assistants]]. The bounded-prompt and review-before-apply approach is the same, but the Adobe connector exposes layered file state instead of a Python execution environment, and the risk profile shifts accordingly.

[^anthropic]: Anthropic, "Claude for Creative Work," 2026-04-28, https://www.anthropic.com/news/claude-for-creative-work?lang=us [^blender]: Blender Foundation, "Blender Python API Documentation," https://docs.blender.org/api/current/ (retrieved 2026-06-14) [^bpyops]: Blender Foundation, "bpy.ops — Operators," https://docs.blender.org/api/current/bpy.ops.html (retrieved 2026-06-14) [^blendermanual]: Blender Foundation, "Scripting & Extending Blender," https://docs.blender.org/manual/en/latest/advanced/scripting/introduction.html (retrieved 2026-06-14) [^mcp]: Model Context Protocol specification, "Tools," 2025-06-18, https://modelcontextprotocol.io/specification/2025-06-18/server/tools (retrieved 2026-06-14) [^tooluse]: Anthropic, "Tool use (function calling)," https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview (retrieved 2026-06-14)

Adobe for creativity is the broadest-scope connector in Anthropic's Claude for Creative Work launch. Anthropic describes it as drawing from 50+ Creative Cloud tools.[^anthropic] Adobe's own launch post describes the connector as letting Claude orchestrate "multi-step workflows across Creative Cloud apps" including Photoshop, Firefly, Express, Premiere, and Lightroom.[^adobe-blog] That breadth is not a feature you should try to use all at once — it is a scope risk you need to actively constrain. Blender's connector has a single API surface (bpy); Adobe's connector reaches across Photoshop, Illustrator, InDesign, Premiere Pro, Express, Lightroom, Firefly, and dozens more.[^cc-tools] Each tool has different file formats, layer models, and destructive-versus-non-destructive patterns.

The production discipline for Adobe connectors is the same as for Blender, but the surface is wider: write a prompt scoped to one tool, one file, and one action. Don't write "make me a campaign asset." Write "in Photoshop, add an Adjustment Layer to the Background layer in logo-comp-v2.psd with these color grading settings, then stop."

This chapter builds on the workflow model from [[courses/claude-mcp-mastery/01-use-mcp-as-the-creative-workflow-layer]] and applies it specifically to layered Adobe files, brand constraints, and export setup. For a deeper look at how MCP connectors chain across multiple servers, see [[courses/production-agents-claude-agent-sdk-mcp-connector/03-mcp-connector-multi-server]]. Keep [[glossary/human-in-the-loop]] open — it is the central design pattern for this chapter.

Understand what the Adobe connector exposes

The connector gives Claude language-level access to Creative Cloud operations. Anthropic positions Adobe for creativity as a way for Claude to help with AI-assisted design, format bridging, workflow exploration, and repetitive production tasks.[^anthropic] Adobe frames both the connector and its Firefly AI Assistant as part of a longer-term "agentic creativity" vision — users define creative intent, and AI coordinates execution across interconnected apps.[^petapixel] In practice that means:

• Generating and adjusting artwork, layouts, and compositions in response to natural-language prompts
• Running repetitive operations — batch-resizing exports, applying the same color treatment across a set of images — that would take a human a long time to do manually
• Translating between Creative Cloud formats: an Illustrator vector into a Photoshop Smart Object, a Premiere sequence exported to a web delivery format
• Explaining how to use a specific Creative Cloud feature when you are learning a new tool

None of those jobs should happen without a task boundary and a review step. Each is a scoped action on a specific file, not an open-ended design commission.

Separate tasks into distinct tool boundaries

A campaign workflow that starts with a brief and ends with print and web deliverables might touch Photoshop, Illustrator, InDesign, and Premiere Pro. Each is a separate tool boundary. Separate them deliberately.

Here is an example breakdown for a product-launch campaign:

1. Concept exploration (Adobe Express or Illustrator) — Generate three layout compositions from the campaign brief. Human review: choose one direction before any production work begins.
2. Vector asset refinement (Illustrator) — Claude adjusts specific vector elements per the chosen direction. Human review: logo placement, color palette, typography match.
3. Photoshop compositing — Claude adds a product image as a Smart Object and applies a masked background treatment. Human review: source image license, mask quality, layer names.
4. Export setup (Photoshop or Illustrator) — Claude prepares export presets for web (PNG 72 dpi), print (PDF/X-4), and social media (1:1, 4:5, 16:9). Human review: output specs before export.
5. Video adaptation (Premiere Pro) — Claude creates a 15-second animation from the approved still. Human review: motion, audio sync, final render settings.

Each step names the tool, the file, and the expected output. Each has a human review gate before the next step begins. The connector never jumps steps.

Instructions for adding a clipped Curves Adjustment Layer named 'Shadow-Lift Curve' above 'BG Photo', with exact shadow (0→20) and highlight (230→210) curve point values. The response should note that the adjustment is non-destructive and remains editable. It should not recommend flattening or exporting.

Recognize destructive operations before they run

Adobe's non-destructive editing features exist precisely because destructive operations are permanent.[^adobe-nde] In Photoshop:

• Non-destructive: Adjustment Layers, Smart Object transforms, masks, filter galleries on Smart Objects, layer blend modes.
• Destructive: Flattening layers, merging visible layers, rasterizing a Smart Object, applying a filter directly to a pixel layer, Stamp Visible (Ctrl+Shift+Alt+E).

When Claude proposes an action, scan the response for these terms before running anything. "Merge down," "flatten image," "rasterize layer," or "apply adjustments" should trigger a review pause. Ask yourself: can I undo this without reloading from the last saved version?

The MCP specification recommends that applications expose visible invocation indicators so humans can review what will happen before it does.[^mcp] In an Adobe workflow, your review step is the gap between Claude describing an action and you executing it. Never run an action you haven't read first.[^tooluse]

Write prompts that preserve brand constraints

Adobe connector prompts for branded work must include the brand constraints explicitly. Claude does not have access to your brand guide unless you provide it in the prompt. A minimal brand-constraint block looks like this:

Brand constraints for this file:
- Primary color: #C8102E (never approximate — exact hex only)
- Secondary color: #FFFFFF
- Typeface: Helvetica Neue, weight Bold for headlines, Regular for body
- Logo safe zone: 40 px clear space on all sides at 300 dpi
- Restricted imagery: no stock photos of generic office settings; no AI-generated human faces
- Asset source: all images in this file are client-provided; no Adobe Stock in this comp

Include this block at the top of every connector prompt that touches a branded file. After Claude returns a result, check each constraint before approving the step.

Source attribution belongs in the same block. Name where each asset came from: Adobe Stock license number, client-provided asset name, or Creative Commons license type and URL. If the connector generates new imagery or suggests adding an asset, require explicit source declaration before accepting it.

Campaign brief: Launch a social media campaign for a new running shoe. Deliverables: 3 Instagram feed posts (1:1, 1080×1080 px), 2 Instagram Story frames (9:16, 1080×1920 px), 1 Facebook banner (1200×628 px). Brand colors: #FF5500 (primary), #1A1A1A (dark), #FFFFFF. Font: Futura PT Bold. Product image: provided by client (client-asset-shoe-01.jpg, licensed for digital use). No stock photography.

Brand constraints: - Primary color #FF5500 only — no gradients from this color - Futura PT Bold headlines, Futura PT Book body text - Logo safe zone 60px on all sides at 72dpi - Client asset only — no Adobe Stock, no AI-generated imagery" expectedOutput="A numbered task list with: (1) layout concept in Adobe Express or Illustrator scoped to one deliverable format with human approval before scaling; (2) Photoshop compositing step naming the client asset and layer structure; (3) brand-constraint verification step naming each constraint from the brief; (4) export setup as a separate task with format/resolution specs per deliverable; (5) final human approval gate before delivery. Each step should name the tool, file, expected output, and who reviews." />

Keep export setup as a separate approval gate

Export is a one-way step for many formats. A JPEG flattens layers; a PDF/X-4 embeds fonts and color profiles; an H.264 MP4 bakes motion and audio into a single stream. None of those are easily undoable in the way that a Photoshop layer edit is.

Treat export as its own bounded task with three mandatory steps:

1. Agree on specs before exporting. Name the format, color profile, resolution, and destination in the prompt — for example: "export as JPEG, sRGB, 85% quality, 1080×1080 px, to the /exports/social/instagram/ folder."
2. Review the source file one last time. Check layer names, visible layers, artboard crop, and embedded fonts before the export runs.
3. Verify the output. Open the exported file in the correct viewer — a web browser for JPEG/PNG, Acrobat for PDF — and confirm dimensions, color rendering, and text legibility before distributing.

Practice: campaign brief to connector-safe task list

Take this brief and build a connector-safe task list before opening the Adobe connector:

> A B2B software company wants a landing-page hero image and three supporting icon sets. Brand colors: #0A2540 (navy), #00D4AA (teal), #FFFFFF. Font: Inter, Bold for headlines. All illustrations must be vector. No photography. The hero image will be used at 1440×810 px for web and 300 dpi for print.

Your task list must include:

1. Tool boundary for each deliverable — which Creative Cloud app handles vector icons vs the hero composition
2. Non-destructive requirements — what must stay in an editable layer format and why
3. Brand constraint block — written in the format from this chapter, ready to paste into a connector prompt
4. Source attribution statement — where the illustrations will come from
5. Human approval gates — named after each step (who approves what)
6. Export spec — separate from the composition step, with format and resolution for each deliverable

Compare your task list against the pattern from the practice in [[courses/claude-mcp-mastery/02-automate-blender-scenes-without-hiding-the-python-layer]]: bounded prompt, named target, verification step, explicit constraints. The Adobe connector uses the same pattern with a wider tool surface and higher brand-risk exposure at each step.

In the next chapter, [[courses/claude-mcp-mastery/04-ground-ableton-help-and-music-workflows-in-official-documentation]], the connector surface shifts again — from file-based layered assets to a live software environment with sessions, clips, and audio routing. The bounded-prompt discipline carries forward; the verification model changes.

[^anthropic]: Anthropic, "Claude for Creative Work," 2026-04-28, https://www.anthropic.com/news/claude-for-creative-work?lang=us, Retrieved 2026-06-14 [^adobe-nde]: Adobe, "Use layer masks to target adjustment or fill layers," Updated 2026-02-23, https://helpx.adobe.com/photoshop/desktop/create-manage-layers/color-adjustment-fill-layers/use-layer-masks-to-target-adjustment-or-fill-layers.html, Retrieved 2026-06-14 [^mcp]: Model Context Protocol specification, "Tools," 2025-06-18, https://modelcontextprotocol.io/specification/2025-06-18/server/tools, Retrieved 2026-06-14 [^tooluse]: Anthropic, "Tool use (function calling)," https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview, Retrieved 2026-06-14 [^adobe-blog]: Adobe, "Adobe for creativity: a new way to create with Adobe, now in Claude," 2026-04-28, https://blog.adobe.com/en/publish/2026/04/28/adobe-for-creativity-connector, Retrieved 2026-06-14 [^cc-tools]: Adobe, "Adobe for Creativity available in Claude," 2026-04-28, https://developer.adobe.com/adobe-for-creativity, Retrieved 2026-06-14 [^petapixel]: Garibaldi, Kate, "Claude AI Can Orchestrate Creative Workflows Across Adobe Apps," PetaPixel, 2026-04-28, https://petapixel.com/2026/04/28/claude-ai-can-orchestrate-creative-workflows-across-adobe-apps/, Retrieved 2026-06-14

The Ableton connector works differently from the Blender and Adobe connectors. Anthropic describes it as grounding Claude's answers in official Live and Push documentation.[^anthropic] That means Claude is not improvising music advice from training data — it is navigating and interpreting the same documentation you would read yourself. The connector navigates official Ableton documentation as a server-side tool — no local Ableton integration is required.[^claude-tools] The connector makes that navigation faster, but it does not make Claude a music producer or a decision-maker about your creative choices.

The production lesson for Ableton is: use the connector for what documentation can answer, and do not use it for what documentation cannot answer. Documentation can tell you how MIDI routing works, what a Rack device expects, how to configure an audio export, and what changed in each Live 12 build — see the release notes for your specific version.[^live12-beta] Documentation cannot tell you whether the kick should hit at 808 Hz or 110 Hz in your specific track. The connector excels at the first category and must stay out of the second.

For MCP fundamentals, see [[courses/claude-tool-use-from-zero/04-handling-advanced-data-and-resources]] and [[glossary/tool-use]]. This chapter assumes you have Ableton Live installed and can identify the Session and Arrangement views. No music theory prerequisite is required.

What documentation grounding means in practice

When Claude answers a question through the Ableton connector, it draws from official Ableton documentation — the Live manual, Push guides, device reference, and release notes.[^ableton-welcome] This is meaningfully different from asking a general-purpose AI model about Ableton. A general model draws from training data that may include incorrect tutorials, outdated workflow guides, and advice for older versions. A documentation-grounded connector answers from the same authoritative source Ableton ships to its users.

The practical implication: the connector's answers are as good as the documentation it can reach. When a feature is well-documented — MIDI routing, audio export formats, Rack device chains, automation modes — the connector gives accurate, version-specific guidance. When a feature is underdocumented — undocumented keyboard shortcuts, internal behavior that varies by hardware setup, edge cases in Push firmware — the connector may not have a good answer and will say so.

The MCP specification recommends that implementations keep a human in the loop: applications should display which tools are exposed to the model and present confirmation prompts before sensitive operations execute.[^mcp] For the Ableton connector, that means your Claude interface should surface the connector as an active tool and confirm before any documentation action runs. The calibration is: trust documentation-grounded answers on feature behavior; verify on subjective or version-specific claims; override immediately on musical taste.

Write context-rich troubleshooting prompts

A good Ableton connector troubleshooting prompt has four components:

1. Environment — Ableton Live version, OS, Push model (if in use), audio interface
2. Symptom — what is happening, including any error messages or unexpected behavior
3. Expected behavior — what you expected to happen, referencing the feature by name
4. What you have already tried — steps taken so the connector does not repeat them

Here is the structure:

Environment: Ableton Live 12.0.2, macOS 15.4, Push 3 (standalone mode), Focusrite Scarlett 2i2 Gen 4
Symptom: MIDI notes from an external keyboard (Roland RD-88) are not reaching the instrument on Track 3 (Analog). The MIDI activity indicator on the track header does not flash when I play notes.
Expected behavior: External MIDI should route from the MIDI input of the Scarlett → Ableton MIDI preferences → Track 3 with "In" arm enabled.
Already tried: Confirmed the RD-88 appears in Ableton MIDI Preferences > Input. Confirmed Track 3 is record-armed. Confirmed the Scarlett MIDI port is enabled for "Track" input in MIDI Preferences.
Question: What else in Live 12 could prevent MIDI from reaching a track that is armed and whose input port is enabled?

This prompt gives the connector enough context to cross-reference the correct Live 12 MIDI routing documentation, distinguish your setup from a simpler case, and return a specific checklist rather than generic advice.

A numbered checklist of additional causes to check, drawing from the Live 12 MIDI routing documentation: (1) check that the correct MIDI channel is selected on Track 3's input — it may be set to a specific channel that doesn't match the RD-88 output channel; (2) confirm 'Monitor' is set to 'In' (not 'Auto') on Track 3 since the track must be in record-monitoring mode to pass MIDI through; (3) verify no other track in the session is claiming exclusive MIDI input from the same source; (4) check if Push 3 standalone mode has any MIDI override active. Each item should reference the relevant section of the Live 12 manual.

After the connector returns a checklist, work through it in order. Add a verification note after each step: "checked — channel was set to 'All', changed to Channel 1 to match RD-88 default output — MIDI now flowing." This gives you a session log and a trail for future reference if the problem recurs.

The same four-component structure works for automation and export questions:

Environment: Ableton Live 12.0.2, macOS 15.4, Push 3 (standalone mode)
Question: How do I draw automation for filter cutoff on a Wavetable device (Track 5) in Arrangement view?
Context: Pressed A to enter Automation mode; volume and pan lanes visible. Cannot find Wavetable cutoff in the parameter dropdown.
Goal: Automate the cutoff to open over 8 bars — need the exact steps to select the parameter and draw the envelope.

Environment: Ableton Live 12.0.2, macOS 15.4
Question: How do I export individual stems from an Arrangement view session using File > Export Audio/Video in Live 12?
Context: 12-track session, all clips in Arrangement view. Target format: 24-bit WAV, 48 kHz. Need separate files for drums, bass, keys, and vocals — not a master mixdown.
Already tried: File > Export Audio/Video renders the master. Not clear which settings produce per-track stem files in Live 12.

Separate technical guidance from musical decisions

The documentation boundary is also the taste boundary. When Claude's answer involves a factual claim about how Ableton works, verify it against the documentation if you are unsure. When Claude's answer involves what you should do creatively — tempo, structure, sound design, mix balance — that is outside the connector's competence.

Here are concrete examples of where the line falls:

A well-scoped connector session stays in the left column. When a question drifts into the right column — "what should my filter cutoff be?" — redirect it: "tell me how to automate filter cutoff in Arrangement view and I'll set the values myself."

Build a verification checklist before changing your Live set

Before any connector-guided change to a production Live set, require a numbered verification checklist. This parallels the script-review step from ch02 (Blender) and the approval gate from ch03 (Adobe). In Ableton, the checklist covers:

1. Save the current set — File > Save Live Set. Name with a _preChange suffix if this is a significant modification.
2. Note the current state — before changing routing, note which tracks are armed, which send levels are set, which clips are playing.
3. Make one change at a time — do not apply five routing changes in sequence without testing after each one.
4. Verify with Ctrl+Z available — Ableton's undo history covers most session changes. Know the depth of your undo history before making changes that approach the configurable limit (set in Live's Preferences > Record, Warp & Launch).
5. Test in isolation — solo the affected track before returning to the full mix.
6. Document what changed — add a locator to mark the change point: right-click in the arrangement scrub area > Add Locator, then rename it to describe what the connector session modified.

Sidechain compression is one of the most frequently misrouted effects in Live — the Compressor device's dedicated Sidechain section is documented step by step in Ableton's audio effect reference, which the connector can cross-reference directly.[^ableton-effects]

Environment: Ableton Live 12.0.2, macOS 15.4. Session has 8 tracks. Bass is on Track 4, Kick on Track 2." expectedOutput="Pre-change checklist: save the set, note current compressor settings if any, ensure kick track has a return send or audio routing point. Setup steps: (1) on Kick track, create a new return send or use an audio effect rack with sidechain output; in Live 12, open the Compressor on Bass track, enable Sidechain, select Kick as the sidechain source from the input selector. Parameter guide: Threshold controls when compression kicks in based on the kick signal; Attack/Release control how quickly the bass ducks and recovers; Ratio controls depth. Post-change checklist: play the session, solo the bass and listen for compression pumping in time with kick, check GR meter on compressor, verify the kick sounds unchanged." />

Practice: diagnose a Live routing problem

Open a Live set with at least three audio tracks. Set up a deliberate routing problem: for example, disable the send level on a Return track that your reverb send depends on, then write a connector prompt that asks Claude to help you diagnose why reverb is not audible on Track 1.

Your prompt must include:

1. The full environment block (Live version, OS, interface)
2. The symptom with specific observable details (which track, what is missing, what the meters show)
3. What you have already checked
4. A request for a numbered verification checklist before you change anything in the set

After Claude returns the checklist, work through each step and note your findings alongside each item. This is the same verification discipline from [[courses/claude-mcp-mastery/02-automate-blender-scenes-without-hiding-the-python-layer]] — bounded context, explicit verification, no open-ended changes.

In the next chapter, [[courses/claude-mcp-mastery/05-bridge-tools-without-creating-invisible-handoffs]], the workflow expands beyond a single tool. The bounded-prompt and verification-checklist discipline you have practised across Blender, Adobe CC, and Ableton now applies to cross-tool handoffs where file provenance, format translation, and checkpoint documentation become the primary risk surface.

[^anthropic]: Anthropic, "Claude for Creative Work," 2026-04-28, https://www.anthropic.com/news/claude-for-creative-work?lang=us [^claude-tools]: Anthropic, "Tool use with Claude," Claude Developer Documentation, https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview [^live12-beta]: Ableton, "Live 12 Beta Release Notes," https://www.ableton.com/en/release-notes/live-12-beta [^ableton-welcome]: Ableton, "Welcome to Live," Ableton Live 12 Reference Manual, https://www.ableton.com/en/manual/welcome-to-live [^push-release]: Ableton, "Push with Live 12 — Release Notes," https://www.ableton.com/en/release-notes/push-12 [^live12-4]: Ableton, "Live 12.4 is out now — with Link Audio, updated devices and more," 2026-05-05, https://www.ableton.com/en/blog/live-12-4-is-out-now [^mcp]: Model Context Protocol specification, "Tools," 2025-06-18, https://modelcontextprotocol.io/specification/2025-06-18/server/tools [^ableton-effects]: Ableton, "Live Audio Effect Reference," Ableton Live 12 Reference Manual, https://www.ableton.com/en/manual/live-audio-effect-reference

Before you enable any creative connector for a team, production readiness requires four things: per-tool permission boundaries, approval gates for destructive and licensed actions, a cross-tool rollback plan, and a clear decision about where the connector runs.[^anthropic] This chapter converts Anthropic's intended boundedness into enforceable structure you can ship.

The nine connectors in the creative launch — Ableton, Adobe Creative Cloud, Affinity by Canva, Autodesk Fusion, Blender, Resolume Arena, Resolume Wire, SketchUp, and Splice — each bring a distinct permission surface.[^connectors] What they share is the same failure mode: a connector session with write access to production assets, no approval gates, and no rollback plan is not a creative assistant — it is a liability.[^ch05]

For the MCP concepts that underpin permissions and transport architecture, see [[courses/mcp-from-first-principles-to-production/04-oauth-dpop-auth]] and [[courses/production-agents-claude-agent-sdk-mcp-connector/05-production-deploy-observability]].

Define per-tool permission boundaries

The MCP specification defines tools as named, callable operations with typed input schemas.[^mcp] A connector server exposes a list of tools; Claude can invoke only the tools the server makes available. This is the first lever: configure each server to expose only the tools the workflow needs, and nothing more.

Least privilege by tool category:

Start each new connector session at the left column of this table. Grant write access only when the workflow requires it, and document the reason. If you cannot name a specific step in the workflow that needs the permission, do not grant it.

Restricting tool exposure. Most MCP server implementations allow you to configure which tools are active at server startup. The Blender MCP server exposes Python execution tools; a read-only audit session does not need those. Configure a separate server profile for read-only review runs and a separate profile for edit sessions. The two profiles should never share a running instance — a read-only audit session should not be able to escalate to write access by calling a tool that happens to be registered.

Add approval gates for destructive and licensed actions

An approval gate is a workflow checkpoint that requires a named human to review specific output before a connector action runs. It is not a generic confirmation prompt. A gate answers a specific question: "Has [person] reviewed [output] and confirmed that [action] should proceed?"

Three categories of actions that require a gate:

1. Destructive actions — any action that overwrites or deletes source material, or that produces an output that cannot be undone without a backup. Examples: overwriting a .blend scene with a modified version, flattening Photoshop layers, bouncing an Ableton session to a new audio file that replaces the original.

Gate template: `` Gate: Destructive write — [action description] Review required by: [name or role] What to verify: [specific question the reviewer must answer] Confirmation: [yes/no with reason] ``

2. Licensed actions — any action that modifies, exports, or bundles an asset with third-party license terms. Splice samples, Adobe Stock imagery, purchased fonts, and stock video all carry terms that define what derivative uses are permitted. A connector session that exports a composed asset containing these materials must pause and confirm that the license covers the intended distribution.

Gate template: `` Gate: Licensed asset in export Asset: [name, source, license summary] Intended distribution: [delivery platform, client, or internal use] License permits this use: [yes / unknown — verify with source] ``

3. External actions — any action that sends an asset outside the local environment. Uploading to an Adobe CC library, pushing to a client FTP, or exporting to a cloud render farm all have consequences that cannot be undone locally. The gate must confirm the destination, the asset version, and who authorized the external delivery.

Implementing gates without a formal approval system. If you are running a local connector session without a gateway or approval queue, gates still apply — implement them as explicit connector prompts that output a checklist and wait for typed confirmation before proceeding:

Claude: Before I overwrite product-hero-v4.blend, confirm:
  1. product-hero-v4.blend is backed up at /backups/2026-06-14/product-hero-v4.blend [y/n]
  2. You have reviewed the material assignments in the modified scene [y/n]
  3. The client has not approved the current version for archive [y/n]
  Type 'proceed' to continue or 'cancel' to stop.

A gateway implementation (covered in [[courses/mcp-from-first-principles-to-production/04-oauth-dpop-auth]]) can formalize this as a structured approval step in the server layer, with a logged record of who approved and when. For team use, the gateway implementation is strongly preferred — it provides an audit trail that a typed prompt does not.

Build a rollback plan that works across tools

Before any connector session that modifies files, create a versioned copy. This is the single most important production habit and requires no tooling beyond a file copy. Everything else in rollback planning builds on this.

Three-tier rollback:

Most connector failures — wrong parameter, unexpected output, corrupted import — are recoverable at Tier 1 or Tier 2. Tier 3 is needed when the session spans multiple days, multiple operators, or when the client has an approved version that must be preserved.

Per-tool rollback patterns:

Blender — Copy the .blend file before any connector session that calls Python execution tools. Name the copy with the date and session identifier: product-hero-v4_2026-06-14_pre-connector.blend. Store it outside the working folder so a recursive project export does not include it in a client deliverable. Generated Python scripts should be committed to version control separately from the blend file — this gives you the ability to audit what the connector executed even after the session closes.[^blender-api]

Adobe CC — Use Photoshop's "Save As" to create a dated copy before a connector session modifies layers. For Premiere and After Effects, duplicate the project file. If you use Adobe CC Libraries for shared assets, note that library writes may propagate to collaborators immediately — treat library uploads as external actions requiring a gate.

Ableton — The Ableton connector is documentation-grounded and does not directly edit Live sets in the current connector implementation.[^anthropic] If your workflow uses Ableton alongside other connectors (e.g., exporting audio that feeds an Adobe Premiere session), apply rollback at the Ableton boundary: copy the .als project file and all linked audio samples before any audio export that feeds a downstream connector.

Cross-tool rollback. In a multi-connector chain (see [[courses/claude-mcp-mastery/05-bridge-tools-without-creating-invisible-handoffs]]), each handoff point is a rollback checkpoint. Before Step N, the output of Step N-1 must be saved in a state that can be fed back in if Step N fails. A cross-tool rollback plan names those checkpoints explicitly:

Rollback checkpoints for [workflow name]:
  Step 1 output: product-hero-v4-lit.blend (saved before Blender-to-Adobe handoff)
  Step 2 output: hero-composite-v1.psd (saved before Adobe-to-Premiere handoff)
  Step 3 output: hero-sequence-v1_draft.prproj (saved before final export)
  Rollback to Step 1: restore product-hero-v4-lit.blend and re-run Steps 2–3
  Rollback to Step 2: restore hero-composite-v1.psd and re-run Step 3 only

Decide when local is enough and when to use a gateway

The MCP specification supports two transport types: local servers that communicate via standard input/output (stdio), and remote servers that communicate over HTTP with Server-Sent Events.[^mcp] The transport choice determines the security boundary.

Local connector (stdio transport) is appropriate when: - A single operator runs the workflow on their own machine - The connector accesses only files on the local filesystem or local application state - The workflow does not require shared credentials or team-level audit logging - The session is bounded to a single work session (no cross-session state)

Remote connector / gateway is required when: - More than one person runs the workflow (shared credentials, shared audit trail) - The connector reaches external APIs or cloud services that require centralized authentication - The studio needs a record of every connector action accessible to a team lead or compliance officer - The workflow involves client-billable work where audit evidence is contractually required

When to reject a connector workflow entirely:

Some workflows should not use connectors at all, regardless of permission and gateway configuration:

• Live performance assets without a rehearsal copy: Resolume Arena and similar real-time media servers operate in contexts where a connector failure is visible to an audience. No connector session should run against live-performance assets without a fully tested, rehearsed alternative in place.
• Regulated or licensed content workflows: If your studio's output is subject to regulatory review (broadcast standards, government contracts, healthcare imagery), the approval-gate pattern is insufficient — the full workflow must be reviewed by a qualified human, and connector actions may not be auditable in the required format.
• Multi-party licensed assets without confirmed clearances: If a cross-tool export bundles assets whose licenses have not been individually confirmed for the intended delivery, the workflow must stop at the licensing gate and not proceed until clearances are documented.

Produce a launch checklist for this studio. Include: 1. A permissions table (per connector: what read/write/export access is granted and why) 2. Three approval gates (name the action, what the reviewer checks, and the confirmation format) 3. A cross-tool rollback plan with named checkpoints 4. A gateway decision: local or remote — explain why and what the gateway would need to provide" expectedOutput="Permissions table covering Blender (read: scene/materials/render settings; write: Python execution for bounded scene edits only; no export to external without approval gate) and Adobe CC (read: layer names/color profiles; write: non-destructive layer edits; no CDN/library upload without gate). Three gates: (1) Blender-to-Adobe handoff — 3D artist reviews exported EXR sequence before compositor import; (2) composite approval at week 2 — motion designer + client sign off on PSD/Premiere sequence before any H.264 or PDF export; (3) final delivery gate at week 4 — studio lead confirms format specs and license clearances before ProRes/H.264/PDF upload. Rollback: checkpoint 1 = pre-session .blend copies; checkpoint 2 = PSD snapshot at client approval; checkpoint 3 = Premiere project copy before final export. Gateway decision: remote gateway recommended because three operators share the workflow, client approvals require an audit trail, and broadcast delivery may require compliance evidence — local stdio is insufficient for multi-user audit requirements." />

Practice: produce a launch checklist

Using the patterns in this chapter, produce a launch checklist for a connector workflow you design. The checklist must include:

1. Permission boundary table — for each connector in your workflow, list: what read access is granted, what write access is granted (with the reason), and what is explicitly rejected.
2. Approval gate register — for each gate in your workflow, name: the action that requires approval, who is the named reviewer, what specific question they must answer, and what the confirmation format is.
3. Rollback checkpoint map — for each handoff point in the workflow, name: what file or state is saved as a checkpoint, where it is stored, and what the restore path is if the next step fails.
4. Gateway decision — state whether the workflow runs on a local stdio connector or requires a remote gateway, and give one concrete reason for the choice.

Compare your checklist against the criteria in this chapter: does every write access have a named reason? Does every approval gate answer a specific question rather than a generic "approve"? Does every rollback checkpoint name the restore path, not just the backup location? These are the differences between a checklist that passes production review and one that fails on first incident.

This course's capstone — designing a reviewable creative workflow for a fictional studio brief — draws on all six chapters. The deliverable is not a final creative asset; it is a connector runbook with prompts, expected outputs, permission boundaries, approval gates, file naming conventions, and rollback steps. The production checklist from this chapter is the production-readiness gate for that runbook.

[^anthropic]: Anthropic, "Claude for Creative Work," 2026-04-28, retrieved 2026-06-14, https://www.anthropic.com/news/claude-for-creative-work?lang=us [^ch05]: See [[courses/claude-mcp-mastery/05-bridge-tools-without-creating-invisible-handoffs]] for cross-tool handoff patterns, format translation risks, and audit-note conventions. [^mcp]: Model Context Protocol specification, "Server Tools," 2025-06-18, retrieved 2026-06-14, https://modelcontextprotocol.io/specification/2025-06-18/server/tools [^tooluse]: Anthropic, "Tool use (function calling)," retrieved 2026-06-14, https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview [^blender-api]: Blender Foundation, "Blender Python API Documentation," retrieved 2026-06-14, https://docs.blender.org/api/current/ [^connectors]: Zac Hall, "Anthropic releases 9 Claude connectors for creative tools, including Blender and Adobe," 9to5Mac, 2026-04-28, retrieved 2026-06-14, https://9to5mac.com/2026/04/28/anthropic-releases-9-new-claude-connectors-for-creative-tools-including-blender-and-adobe