Thesis
AI isn’t a single gadget you “use.” It’s a protocol: a repeatable set of interactions—inputs, constraints, feedback loops, provenance, and edits—that lets humans and machines co-create across mediums (text, image, video, audio, code). When you see AI this way, you stop asking, “What can this tool generate?” and start asking, “What creative system can I run?”
What changes when you call it a protocol?
A tool is usually a one-direction interface: you operate it, it outputs.
A protocol is an agreement for coordination: it defines how parties communicate and build on each other reliably (think: how the web works because HTTP is shared).
So with AI:
- Prompts/briefs are the handshake.
- Constraints are the contract.
- Iterations are the conversation.
- Selection/curation is the taste layer.
- Edits are the production layer (where quality actually happens).
- Provenance/credits are the accountability layer (how we keep trust).
This matches how real creative work already functions: brief → drafts → critique → revisions → final.
Core claims (and why they matter)
Claim A — Creativity is an iterative loop; AI accelerates the loop.
Creativity isn’t a lightning bolt; it’s a cycle of divergence (generate options) and convergence (choose + refine). AI compresses this cycle so you can explore more “maybe” ideas per hour—without committing to them. Tools like Photoshop’s Generative Fill are literally built around non-destructive iteration: add/remove/modify through text, then keep editing like a normal pro.
Claim B — Protocol framing forces us to design for composability, not novelty.
A protocol mindset means: versioning, reusable building blocks, and cross-tool interoperability. You can see this trend in creative suites that let you route between models and modalities—image/video/audio/design—rather than worshiping a single “magic model.” Adobe Firefly, for example, positions itself as a multi-model creative space (including third-party models) so creators can move from ideation to production without hopping universes.
Claim C — Protocol framing makes governance possible without killing creativity.
If AI is “just a tool,” governance becomes whack-a-mole.
If AI is a protocol, you can govern at stable choke points: provenance, consent, logging, licensing, and attribution. Standards like C2PA Content Credentials are explicitly aimed at recording an asset’s provenance and preserving that history as it’s edited—basically a “trace” layer for digital media.
Claim D — The creator’s job shifts from “making outputs” to “directing systems.”
The artist becomes the orchestrator: setting constraints, picking data references, deciding what’s in-bounds, curating variations, and doing the final edit passes. That’s why the most compelling AI art rarely looks like “prompt dump”; it looks like a designed pipeline. Refik Anadol’s work explicitly treats machine intelligence as a collaborator and uses large datasets + algorithms to produce curated visual experiences.
Objections (and the protocol answers)
Objection 1: “AI will homogenize art.”
Yes—if your protocol is “type prompt → accept first output.”
Counter: build protocols that force uniqueness: private reference libraries, constraint-first briefs, personal post-processing, and “taste checkpoints” where you reject 90% of outputs.
Objection 2: “AI steals / breaks authorship.”
This is exactly why protocol thinking matters: it spotlights consent + provenance + licensing as first-class layers, not optional vibes. The music world is already moving toward licensing frameworks with AI generators (messy, evolving, but real).
Objection 3: “AI makes people lazy.”
Bad protocols make people lazy. Great protocols make people dangerous (in the best way): faster exploration, stronger critique, better final craft.
Implications
- Designers/builders: make AI workflows modular, inspectable, versioned, and non-destructive.
- Creators: treat prompts like choreography; treat outputs like raw material.
- Regulators/industry: focus on provenance, consent, impersonation safeguards, and licensing rails—not blanket bans.
2) In-depth article: The Creativity Protocol — how AI becomes infrastructure for imagination
Stop treating AI like a gadget. Treat it like a stack.
When a new creative technology shows up, we first call it a trick. Then we call it cheating. Then we quietly realize it’s infrastructure.
Cameras didn’t kill painting. Sampling didn’t kill music. Nonlinear editing didn’t kill cinema. Each shift changed the “unit of creativity” from a single artifact to a workflow.
AI is that shift on steroids—but only if we stop thinking of it as a shiny button and start seeing it as a protocol for creative interaction.
A protocol is powerful because it:
- scales beyond a single product,
- creates a shared language,
- enables interoperability,
- and becomes a platform where culture can build.
That’s what’s happening right now: AI is becoming the shared layer that lets ideas move between text, image, video, audio, and code—fast.
From automation to collaboration
Most people met AI as automation: “do my homework,” “write the email,” “generate a logo.”
That’s the shallow end.
The deeper shift is collaboration:
- you draft,
- AI riffs,
- you critique,
- AI mutates,
- you direct it into form.
This is why the most useful AI features aren’t “one-shot generators.” They’re non-destructive editors embedded in real workflows (design, photo, film, coding). Photoshop’s Generative Fill, for example, is framed as a way to add/remove/modify elements through text while keeping the rest of the editing pipeline intact.
The Creativity Protocol Stack (a mental model that actually helps)
Think in layers. If you control the layers, you control the outcome.
Layer 1 — Intent (human):
What are you making? For whom? What emotion? What constraints?
Layer 2 — Language (shared interface):
Briefs, prompts, references, “style rules,” negative constraints, examples.
Layer 3 — Model (generative engine):
Text models, diffusion models, music generators, video models.
Layer 4 — Toolchain (production):
Editing, compositing, color, layout, typography, mixing, mastering, code review.
Layer 5 — Memory/Data (personalization):
Your reference library, your canon, your past work, your brand guidelines, your taste.
Layer 6 — Governance (trust + rights):
Provenance, licensing, attribution, consent, impersonation rules, safety filters.
When AI “looks generic,” it’s usually because Layer 1, 5, and 6 are missing. The machine is filling the vacuum with the statistical average of the internet.
Protocol patterns that supercharge creativity (practical, repeatable moves)
1) Constraint-first creation (the anti-slop method)
Before you generate anything, define nonnegotiables:
- palette or tonal range,
- lens/format (even for non-photo),
- narrative POV,
- banned clichés,
- “this must NOT resemble X.”
Constraints don’t limit you—they focus you. They give the model a shape to push against.
2) Divergence → Convergence loops (like a pro studio)
Run two modes on purpose:
Divergence: generate lots of options fast.
Convergence: pick one direction and iterate deeply.
The protocol is: quantity early, quality late.
People who complain AI is generic often never switch modes—they stay in endless divergence.
3) The split-brain workflow: Maker + Editor
Use AI in two roles:
- Maker model: generates wild drafts.
- Editor model: critiques brutally, spots clichés, identifies weak composition, suggests tighter constraints.
This keeps you from getting hypnotized by “pretty.” The editor role protects meaning.
4) Tool-anchored generation (don’t live in the chat box)
The magic happens when AI is tethered to production tools:
- You generate,
- then you edit in the environment where final quality is made.
Adobe’s approach with Firefly is explicitly about being a creative space integrated with production workflows, and it also positions itself around commercially oriented usage choices (like how it handles training sources).
5) Version everything (prompts are code)
A protocol needs version control:
- Save prompts like you save presets.
- Track “what changed” between iterations.
- Keep your best “prompt skeletons” like reusable templates.
This turns inspiration into a repeatable craft—not luck.
6) Provenance by default (trust is a creative advantage now)
As synthetic content floods everything, trust becomes a feature.
Standards like C2PA Content Credentials aim to attach cryptographically bound provenance metadata to media and preserve it through edits—so audiences can inspect an asset’s history.
This isn’t just “safety compliance.” It’s an artistic statement: I’m not hiding the process; I’m proud of the process.
Examples in the wild (how creators already use protocol thinking)
Visual design & photo: non-destructive AI editing
- Photoshop Generative Fill: add/remove/modify via text while staying in a traditional pro editing workflow.
- Firefly: positioned as a multi-model space for generating images/video/audio/design assets, emphasizing workflow integration.
- Midjourney: a text-to-image system framed by Midjourney as a lab/community exploring new mediums—massively used for ideation and style exploration.
- Stability AI / Stable Diffusion ecosystem: pushes open-ish model availability + customization, enabling creators to build more personal pipelines rather than using one locked interface.
Video: control modes + provenance rails
Runway’s Gen-3 Alpha write-up highlights not just text-to-video/image-to-video capability, but also a roadmap of finer-grained controls and mentions using provenance standards like C2PA. That’s protocol energy: controls + safeguards + traceability.
Code as a creative medium: AI pair programming
Creativity isn’t only art; it’s also building systems. Tools like GitHub Copilot explicitly pitch “AI pair programmer” behavior, and their newer agent concepts push toward delegating bounded tasks that then come back for review—again: handshake → work → feedback → revision.
If you do creative coding, this is huge: you can prototype visual experiments faster, then keep the final curatorial control.
Installation & fine art: curated machine collaboration
Refik Anadol’s “Machine Hallucinations” body of work is basically a public demonstration of protocol thinking: datasets + model processes + human direction + immersive presentation. TIME’s coverage of his 2025 work describes training on large archives and collaborating with major compute partners—then curating outputs into a final aesthetic statement.
Music: generative power meets rights + identity
Suno markets rapid AI music generation, and the industry response is increasingly about licensing and guardrails. Recent reporting includes licensing moves involving Suno (after lawsuits), while other cases show how “voice likeness” and impersonation policies can trigger takedowns. This is the governance layer forcing itself into the protocol stack.
The ethical/philosophical punchline: authorship becomes choreography
If AI is a protocol, authorship shifts:
- from “I handcrafted every pixel/note/line”
- to “I designed the system that produced this—then I chose, shaped, and finished it.”
That’s not less artistic. It’s a different kind of artistic responsibility.
But it also raises serious issues:
- Consent: what data trained the models?
- Attribution & compensation: who gets paid?
- Impersonation: do we protect voice/likeness?
- Homogenization: does the average style dominate?
- Power concentration: who owns the protocol layer?
Protocol thinking doesn’t solve these automatically—but it makes them designable.
A creator’s playbook: build your own creativity protocol
Here’s a hardcore, practical template you can steal:
- Write a one-page “taste constitution.”
What you love. What you refuse. Your clichés-to-avoid list. - Build a reference vault.
Your photos, your sketches, your playlists, your typography, your influences. - Create a prompt skeleton library.
Reusable structures: subject → intent → constraints → references → output specs. - Run in phases:
Diverge (many) → Converge (one) → Polish (craft). - Log everything.
Prompts, settings, edits, versions. Your future self will thank you. - Add provenance when it matters.
Treat transparency like a signature, not a confession.
3) Short opinion piece (~300 words): “AI isn’t a tool. It’s the new creative protocol.”
Everyone keeps arguing about whether AI is a tool or a threat. Wrong fight.
AI is a protocol—a new shared language for turning intention into form. And protocols don’t politely stay in one app. They spread. They become infrastructure. Like how the web isn’t “a website tool,” it’s a set of rules that lets billions of people publish, remix, and collaborate at planetary scale.
That’s what’s happening to creativity.
Prompts aren’t magic spells; they’re handshakes. Constraints are contracts. Iteration is the engine. Curation is authorship. Editing is where the work becomes real. When you treat AI like a button, you get disposable content. When you treat it like a protocol, you get a pipeline—a repeatable creative system that turns raw generation into crafted work.
Look at how this is already landing in the real world: non-destructive AI editing inside pro tools, multi-model creative suites, AI pair-programming inside IDEs, text-to-video systems building control modes, and provenance standards trying to keep trust alive in a synthetic media flood.
Here’s the part people miss: protocol thinking is also how we save creativity from the worst outcomes. Because once you admit AI is infrastructure, you can demand infrastructure-grade rules: consent, licensing, attribution, anti-impersonation safeguards, provenance, and transparency.
The future belongs to creators who stop asking, “What can the model do?” and start asking, “What system am I designing?”
AI won’t replace artists.
But artists who build better protocols—better briefs, stronger constraints, sharper taste, cleaner provenance, nastier critique loops—will absolutely replace artists who don’t.
So don’t “use AI.”
Run it. Direct it. Version it. Own the protocol.