DEV Community: anubhavbhatt

Verify Human or AI - A Builder's Guide to Proof-of-Human Verification

anubhavbhatt — Tue, 07 Jul 2026 13:15:04 +0000

At 12:00:00, a retailer drops a thousand pairs of a limited sneaker. By 12:00:30, the entire batch is gone — not to fans, but to a swarm of checkout bots that filled carts faster than any person could click. Swap "sneakers" for concert tickets, GPU restocks, or a free-tier API key, and you've got the same story playing out across the internet right now.

The old defenses (CAPTCHAs, rate limits, phone verification, device fingerprinting) all shared one assumption: that mimicking a human was hard and expensive. That assumption is dead. AI agents can now solve puzzles, spoof devices, and rent phone numbers cheaper than the infrastructure you'd build to stop them.

So the question engineers actually need to answer isn't "is this a bot?" anymore. It's a harder one: how do you let a real, unique human be recognized across the internet, without ever learning who they are? That's what "proof of human" systems try to solve, and a handful of genuinely different approaches now exist. This is a practical look at how they work, how to integrate one, and (the part vendor pitches tend to leave out) where they get expensive, risky, or legally fraught.

Why CAPTCHA Doesn't Work Anymore

CAPTCHA was never really about "proving humanity." It was a puzzle that happened to be easier for humans than for the computer vision of its era. That gap has closed.

A 2024 ETH Zurich study using YOLOv8 object detection solved Google's reCAPTCHAv2 image challenges at close to 100% accuracy, well past the 68–71% success rates bots managed a few years earlier. Ensemble methods that combine multiple AI models now claim around 97% accuracy across CAPTCHA types generally, and even voice CAPTCHAs (once considered a decent fallback) fall to off-the-shelf speech recognition roughly 85% of the time.

The economics make it worse. Solving a CAPTCHA via AI costs on the order of $0.001; routing it to a human CAPTCHA-farm service costs around $0.50. When the automated path is 500x cheaper and more reliable, there's no incentive left for an attacker to stop.

The shift: the industry needs proof of an underlying human behind a request, not just proof that something solved a puzzle.

What "Proof of Human" Actually Means

Strip away any one vendor's branding, and a real proof-of-human system needs to answer five separate questions. Standard authentication (SSO, passkeys, face unlock on your phone) only answers the first:

"Is this the same person as before?" — a login. Doesn't tell you if that person has already registered nine other accounts elsewhere.
Uniqueness — has this specific human already been counted, across the entire population the system serves? At billion-person scale, this is a much harder matching problem than it sounds: an error rate of one-in-a-million per comparison still produces roughly a thousand false matches per query once you're comparing against a billion records. Getting uniqueness right at that scale needs error rates closer to one-in-a-hundred-billion.
Anonymity — can the system prove uniqueness without storing something that identifies the person, or that a breach could later de-anonymize?
Recovery — if someone loses their device or key, can they prove they're the same verified human again, without a single point of failure (a "master secret") that also becomes a single point of catastrophic loss?
Verification / repeat-detection — can a relying party (a website, an app) detect "this human already used their one free trial" without being able to link that human's activity across other, unrelated services?

That last one is usually solved with nullifiers — a value derived from the person's credential, the specific relying party, and the specific action, so the same human produces the same nullifier for the same action every time, but a different, unlinkable nullifier for a different service. It's the mechanism that lets "have you done this before, here" work without becoming a cross-site tracking ID.

A newer, sixth question has shown up as of 2026: delegation — can a human authorize an AI agent to act on their behalf, with the system still able to tell "these ten agent actions all trace back to one human" apart from "these ten agent actions are ten different humans"?

World ID is the most visible implementation of this model today: biometric uniqueness, cryptographic anonymity, nullifier-based verification. It's worth walking through what actually integrating one looks like.

Hands-On: Integrating World ID's IDKit

World ID's developer SDK is called IDKit: available as a drop-in React widget (@worldcoin/idkit), a core JS package (@worldcoin/idkit-core) for custom flows, and native Swift/Kotlin SDKs.

The integration has four moving parts:

1. Register your app. In World's Developer Portal, you get three values: app_id, rp_id (relying-party ID), and a signing_key (a backend secret, never shipped to a client).

2. Backend signs the request. Before your app asks a user to verify, your backend signs a request payload (a nonce plus creation/expiry timestamps) with signing_key. This stops someone from forging a verification request that didn't actually originate from you.

3. Client collects the proof. Your frontend initializes IDKit with your app_id and the signed request. The user completes verification in the World App, which generates a zero-knowledge proof locally. No personal data leaves their device.

4. Backend verifies and stores the nullifier. Your backend forwards the proof to World's API and gets back a verified nullifier:

POST https://developer.world.org/api/v4/verify/{rp_id}
Content-Type: application/json

{
  "nullifier_hash": "0x1a2b3c...",
  "merkle_root": "0x...",
  "proof": "0x...",
  "verification_level": "orb",
  "action": "claim-free-trial"
}

If that call confirms the proof is valid, extract the nullifier_hash and check it against ones you've already seen for this action. That's your replay/reuse guard:

-- nullifiers are large hex values; convert to decimal and store as
-- NUMERIC(78,0) rather than a string, per World's own integration notes
CREATE TABLE used_nullifiers (
  nullifier   NUMERIC(78, 0) PRIMARY KEY,
  action      TEXT NOT NULL,
  created_at  TIMESTAMPTZ DEFAULT now()
);

nullifier_decimal = int(nullifier_hash, 16)

existing = db.execute(
    "SELECT 1 FROM used_nullifiers WHERE nullifier = %s AND action = %s",
    (nullifier_decimal, action),
).fetchone()

if existing:
    raise AlreadyClaimedError("This human has already claimed this action.")

db.execute(
    "INSERT INTO used_nullifiers (nullifier, action) VALUES (%s, %s)",
    (nullifier_decimal, action),
)

That's the whole loop: your backend ends up holding a cryptographic proof of human uniqueness for one specific action, and nothing else. No name, no email, no biometric template, just a number it can check for reuse.

Worth being precise about what this doesn't solve: once that session or API key exists on your side, it's protected by whatever normal session/key security you already have. Proof-of-human establishes uniqueness at enrollment and at each verified action. It isn't a substitute for the rest of your security model.

Delegating to AI Agents Without Losing the Human

The newest piece of this stack is aimed squarely at the sneaker-drop problem from the intro, just inverted: instead of stopping bots from impersonating humans, it's about letting legitimate AI agents act for a human while still being accountable to one.

As of March 2026, World partnered with Coinbase to combine AgentKit (proof that an AI agent is backed by a verified human) with x402, a Coinbase/Cloudflare protocol for stablecoin micropayments between agents. The pitch, in Coinbase's own framing: "Payments are the 'how' of agentic commerce, but identity is the 'who.'"

Mechanically: an agent carries a zero-knowledge proof that it's authorized by a specific verified human, without exposing who that human is. That lets a platform enforce a cap per human (say, three purchases per service before normal payment/fraud checks kick in) rather than a cap per agent, which a bot farm could trivially multiply by spinning up more agents.

Two numbers get cited a lot in coverage of this partnership: "17.9 million people verified globally" and a "$3–5 trillion agentic commerce market by 2030." Both are worth flagging as third-party reporting, not figures published in World's own technical documentation. Treat them as attributed estimates, not settled facts, when you're making an infrastructure decision based on them.

Beyond World ID: How the Alternatives Actually Differ

World ID isn't the only credible answer here, and the alternatives aren't just "worse" or "better": they make genuinely different trust trade-offs.

System	What it actually proves	Biometrics?	Trust model
World ID	Unique human, globally, via one-to-many iris matching	Yes (iris, via the Orb)	Trust the hardware's local anti-spoof detection + the multi-party computation splitting your iris data across independent operators
Privacy Pass / Private Access Tokens (Cloudflare, Apple)	This device passed an integrity check recently	No	Trust the device's secure enclave/OS attester and the token issuer — proves a trusted device, not a unique human
Idena	Passed a synchronous "FLIP" puzzle ceremony with other live participants	No	Trust the ceremony design — human accuracy on FLIP tests runs ~95% vs. ~60–76% for AI at time of testing, but requires recurring live participation roughly every two weeks
BrightID / Proof of Humanity	Vouched for by an existing web of trust	No	Trust the social graph — Proof of Humanity backs this with an on-chain registry (20,000+ verified humans) and a Kleros decentralized court for disputed cases

The distinction that matters most for engineers: Privacy Pass proves a trusted device, not a unique human. If your actual requirement is "stop scripted traffic from an untrusted device," it's a lighter-weight, already-widely-deployed answer. If your requirement is closer to "one human, one vote / one airdrop / one account, globally," device attestation doesn't get you there: you need one of the personhood-specific systems, each with its own cost (biometric hardware and enrollment, or recurring live ceremonies, or dependence on an existing social graph).

The Trade-Offs Nobody Puts in the Pitch Deck

This is the section a lot of proof-of-human explainers skip, and it's arguably the more decision-relevant half of the picture.

Regulatory exposure is real and current, specifically for biometric approaches:

Jurisdiction	Action	Date
Kenya	High Court ruled operations illegal; ordered deletion of biometric data collected without proper approval	May 2025
Spain	Data Protection Agency (AEPD) found GDPR violations; Spain's High Court later upheld a temporary ban on iris-scanning verification	Dec 2024
Hong Kong	Privacy Commissioner ordered a halt to all operations, citing the Personal Data (Privacy) Ordinance	May 2024
Indonesia	Ministry of Communication and Digital Affairs suspended all operations	May 2025
Brazil	National data protection authority (ANPD) issued a ban with daily fines of roughly $8,800 for continued data collection	Jan 2025

If you're evaluating a biometric proof-of-human vendor for a global product, this table belongs in your risk assessment right next to the API docs. Regulatory posture varies by jurisdiction and can change the legality of your integration out from under you.

Attack surface is a second, separate concern from regulation. Iris spoofing isn't hypothetical: a photo of a legitimate iris combined with a contact lens has defeated consumer iris scanners before, most famously the 2016 hack of the Samsung Galaxy Note 7's iris scanner using exactly that technique. World's own engineering blog describes local anti-spoof "presentation attack detection" running on an Nvidia Jetson Xavier NX inside the Orb hardware, a real mitigation, but it's the vendor's own claim, not the result of an independent third-party audit. Forrester's public analysis has been openly skeptical that iris scanning at this scale is immune to simple presentation attacks.

There's also a more mundane, more important risk: after enrollment, the biometric isn't what's protecting the account day-to-day. A private key is. If that key is compromised, an attacker can impersonate the verified identity indefinitely. The biometric solves the one-time uniqueness problem; everything after that is standard key custody, with all the usual failure modes.

Choosing an Approach for Your Product

There's no universal answer, but the decision collapses fairly cleanly once you're honest about what you actually need:

You just need to stop scripted/bot traffic on already-trusted devices (most consumer web/app traffic on iOS, and increasingly other platforms) → Privacy Pass / Private Access Tokens. Lowest friction, already deployed at scale, no biometric enrollment.
You need a hard global-uniqueness guarantee (one account per human for an airdrop, a UBI-style distribution, or a one-vote system) and can accept biometric enrollment and its regulatory footprint → a biometric system like World ID.
You want strong Sybil-resistance without biometrics and can tolerate recurring live participation → Idena's ceremony model.
You're building on top of an existing trusted community → a social-graph system like BrightID/Proof of Humanity.

Whichever you pick, put the regulatory table above next to your technical evaluation. For a biometric system especially, "does this work in the jurisdictions our users are in" is now as load-bearing a question as "does the SDK support our stack."

Conclusion

CAPTCHA's collapse against AI didn't create the "who's really on the other end of this request" problem. It just made it impossible to ignore. What's changed is that there are now several structurally different, credible answers: biometric uniqueness matching, device attestation, live human ceremonies, and social-graph vouching. None of them is a drop-in "solved" checkbox. Each trades off enrollment friction, regulatory exposure, and attack surface differently, and the right choice depends on what you're actually trying to guarantee: a trusted device, or a unique, unrepeatable human.

Claude Fable 5, Explained for Everyone

anubhavbhatt — Fri, 03 Jul 2026 11:24:16 +0000

Every AI model launch comes with the same wave of jargon — benchmarks, comparison charts, terms nobody outside a research lab uses casually. Here's the plain-English version: what Claude Fable 5 actually is, how you start using it, what you can realistically create with it, and how fast it really is.

This isn't a guide for people writing code against it. It's for anyone who wants to use it — for work, for a project, or just to see what it can do.

What is Claude Fable 5?

Claude Fable 5 is Anthropic's most capable AI model to date — the newest and most advanced member of the Claude family of AI assistants. "Most capable" doesn't just mean it knows more facts. It means it's built to handle harder, longer, and more open-ended tasks than earlier Claude models could manage well — the kind of request that isn't a single quick question but a real project.

How to start using it

You access Claude Fable 5 the same way you access any other Claude model: through Claude's web app, its mobile app, or any product built on top of Claude that offers it as a selectable option.

Because it's the most advanced — and most resource-intensive — model in the lineup, don't expect it to always be the automatic default. Many apps and products let you choose which Claude model handles a given task, and Fable 5 is more likely to show up as a deliberate choice for your hardest requests than as the model quietly running in the background for everything.

If you're not sure whether you already have access, the simplest way to find out is to check the model picker in whatever Claude app or product you're using — availability and exact plan details vary and are worth confirming directly rather than assuming.

What you can actually create with it

This is the part that matters more than any spec sheet. Here's what Claude Fable 5 is genuinely good at producing:

Writing that holds together over length. Essays, stories, scripts, long emails — anything where the tone and structure need to stay consistent from the first paragraph to the last, not just sound good in isolated snippets.
Research and analysis. Give it a question that needs pulling information together from multiple angles, or a decision you're trying to think through, and it can work through the reasoning rather than just handing back a surface-level answer.
Full documents, not fragments. Reports, structured plans, even drafts of spreadsheets or presentations — produced start to finish as a complete deliverable rather than something you have to stitch together from several shorter responses.
Reading images, even messy ones. Screenshots, scanned pages, photos of a whiteboard or a receipt — including lower-quality images that would trip up older tools — and pulling out exactly the information you need from them.
Big, loosely-defined projects. This is where it stands out. Instead of a task you need to babysit — asking a question, getting an answer, asking a follow-up — you can hand it something large and open-ended (plan a multi-city trip, restructure a messy document, work through a complicated personal decision) and let it work through the whole thing in stages.
Everyday help with technical stuff, even if you're not technical. Explaining why a spreadsheet formula isn't working, walking through what a confusing error message actually means, or just explaining a piece of code a coworker sent you — you don't need to be a programmer to get useful answers here.

How fast and capable is it, really?

Here's the honest tradeoff: on a genuinely hard, multi-step request, Claude Fable 5 can take noticeably longer to respond than a quick chatbot answer. That's not a glitch — it's working through the problem in more depth before giving you a result, the way a person would take longer to think through a hard problem than to answer a simple one.

The encouraging part is what happens on the other end of that tradeoff. Even when it's set to respond faster (using less of its "thinking" effort), it frequently produces better results than older, previous-generation models did when those models were pushed to their absolute maximum effort. In other words, you don't always need to wait the longest possible time to get a genuinely good answer.

Keep the framing honest, though: for a quick, everyday question — a fact check, a one-line rewrite, a fast back-and-forth — a lighter, faster Claude model will usually feel more responsive. Claude Fable 5's strength is depth on hard problems, not speed on easy ones. Pick the tool that matches the task.

A few things worth knowing

Claude Fable 5 has built-in safety checks, and it will sometimes decline a request outright rather than attempt something it judges too risky. That's a deliberate design choice by Anthropic, not a malfunction — if you hit a decline on something that seems completely reasonable, rephrasing the request or trying a different approach is usually enough.

It's also worth knowing that, as the top-tier model in the Claude lineup, it's generally positioned as the premium option rather than the model used for absolutely everything. Reach for it specifically when a task actually needs the extra depth — a big writing project, serious research, or a genuinely complicated problem — rather than for routine, everyday questions.

Conclusion

Claude Fable 5 is Anthropic's most capable AI model, and it's built for exactly the kind of work that benefits from real depth: long-form writing, research and analysis, full documents, and big, multi-step projects you'd rather hand off than manage piece by piece.

The simplest way to see what it's actually like is to try it on the hardest thing you've been putting off — a big piece of writing, a decision you haven't been able to think through cleanly, a messy project that needs real restructuring — and keep a faster, lighter Claude model on hand for the quick everyday questions in between.

WanGP by DeepBeepMeep : The best Open Source Generative Models Accessible to the GPU Poor

anubhavbhatt — Sat, 27 Jun 2026 03:52:34 +0000

Wan2GP is a powerful, low-VRAM open-source AI video generator that allows users to create text-to-video, image-to-video, and character animations locally. It optimizes popular generative models (like LTX-2 and Hunyuan Video) to run on consumer GPUs with as little as 8GB of VRAM.

Key Features

Low VRAM Optimization: Special memory management allows users to generate up to 20 seconds of video (at 1080p) on cards like an RTX 3060 or RTX 4060.
Web-Based UI: Features an intuitive Gradio interface that makes prompting, selecting models, and applying LoRAs easy.
Character Swap & Animate: Enables you to take still images and animate them, or swap faces/performers in existing videos.

How to Run Wan2GP

You can run Wan2GP in a few different ways depending on your technical comfort:

One-Click Installation (Pinokio): The easiest way to get the web interface running on Windows or macOS is through the Pinokio App Platform.
One-Click Script (GitHub): You can use the Wan2GP One-Click Script for Windows and Linux.
Google Colab: If you do not have a strong GPU, you can utilize the Wan2GP Google Colab Notebook for cloud-based generation.

For additional models, hardware benchmarks, and community troubleshooting, you can check out the official Wan2GP GitHub Repository.

For a visual guide on how to get started with Wan2GP and the LTX-2 model, check out this step-by-step tutorial:
How to create AI movies with Wan2GP

Graphify: Turning Chaos into Connected Knowledge

anubhavbhatt — Sat, 27 Jun 2026 03:25:35 +0000

In the modern digital workflow, information is scattered everywhere—source code repositories, PDFs, screenshots, notes, research papers, tweets, diagrams, and documents. Most tools can search these files individually, but very few can reveal how they connect. Graphify is designed to solve that problem.

Graphify transforms any folder of mixed content into a living knowledge graph—an interactive system that maps relationships between concepts, files, functions, people, ideas, and documents. Instead of browsing isolated files one by one, users gain a navigable map of their knowledge ecosystem.

What Is Graphify?

Graphify is a command-line workflow that converts raw data into structured intelligence through a multi-stage pipeline:

Any input → Knowledge Graph → Clustered Communities → Interactive Outputs

Whether you feed it codebases, notes, academic papers, images, or a personal "raw folder," Graphify extracts entities and relationships, organizes them into communities, and generates outputs such as:

Interactive HTML graph visualizations
GraphRAG-ready JSON files
Plain-language audit reports
Obsidian knowledge vaults
Neo4j exports
GraphML / SVG visualizations

The result is not just searchable data—but explainable structure.

Why Graphify Matters

Most AI assistants can summarize a document or answer a question. But they often lack persistence, transparency, and cross-document reasoning. Graphify fills those gaps in three major ways.

1. Persistent Memory Through Graph Storage

Graphify stores extracted relationships in a reusable graph file. That means your insights survive beyond a single session.

You can return weeks later and ask:

What connects my authentication module to my database layer?
Which papers mention the same optimization strategy?
How is this new note related to prior research?

No need to re-upload or re-read everything.

2. Honest Audit Trails

One of Graphify's strongest features is its transparency.

Every relationship in the graph is labeled as:

EXTRACTED – explicitly found in the source material
INFERRED – logically derived from evidence
AMBIGUOUS – uncertain and flagged for review

This matters because many systems generate confident but unverifiable connections. Graphify shows users exactly what came from evidence and what came from interpretation.

3. Cross-Document Discovery

Some of the most valuable insights are the ones you never thought to ask.

Graphify runs community detection across the graph to uncover hidden clusters of related concepts. This means it can surface surprising links such as:

A function in code solving the same problem as a concept in a research paper
Notes from months ago connected to a new project idea
Similar error-handling patterns across different services
Repeated assumptions hidden across documents

It helps users discover what they didn't know was connected.

How Graphify Works

Graphify follows a structured pipeline that balances deterministic analysis with semantic reasoning.

Step 1: Detect the Corpus

It scans the target directory and classifies files such as:

Code (.py, .ts, .go, etc.)
Documents (.md, .txt)
Papers (.pdf)
Images (.png, .jpg)

Then it estimates scale:

Total files
Approximate word count
Sensitive files skipped
Subdirectory distribution

This prevents users from accidentally processing massive corpora blindly.

Step 2: Structural Extraction (Code Understanding)

For codebases, Graphify uses AST-based parsing to extract:

Functions
Classes
Imports
Modules
Structural relationships

This is deterministic, fast, and reliable.

Step 3: Semantic Extraction

For documents, papers, and images, Graphify performs deeper understanding to identify:

Named entities
Concepts
Citations
Dependencies
Shared themes
Architectural patterns
Similar ideas across unrelated sources

It can even interpret screenshots, charts, diagrams, and whiteboards.

Step 4: Build the Graph

All extracted data is merged into a graph structure consisting of:

Nodes → concepts, modules, people, files, ideas
Edges → calls, references, citations, similarities, dependencies

Then clustering algorithms detect communities.

Step 5: Generate Outputs

Graphify automatically produces multiple usable formats.

Interactive HTML Graph

Open in any browser and explore relationships visually.

Obsidian Vault

Every node becomes a note, communities become folders, and graph view is preserved.

GraphRAG JSON

Use the graph for retrieval-augmented AI systems.

Audit Report

A readable markdown report including:

Key nodes ("God Nodes")
Surprising connections
Suggested questions
Cohesion scores
Token costs

Real Use Cases

Understanding a New Codebase

Join a project and run Graphify before touching anything.

It reveals:

Core modules
Bottlenecks
Hidden dependencies
Shared data flows

Research Synthesis

Drop in:

Papers
Tweets
Notes
PDFs

Graphify builds a unified concept graph that links ideas across sources.

Personal Knowledge Management

Use it on a /raw folder containing everything you collect.

Instead of folders full of forgotten files, you get an evolving memory system.

Team Documentation

Run Graphify continuously in watch mode or Git hooks so every code change updates architecture understanding automatically.

Advanced Features

Incremental Updates

Only changed files are reprocessed.

This saves time and token cost.

Neo4j Integration

Push graphs directly into Neo4j for enterprise-grade graph querying.

MCP Agent Access

Run Graphify as an MCP server so other AI agents can query your knowledge graph live.

Query Modes

Ask natural questions like:

"What is AuthModule connected to?"
"Explain SwinTransformer"
"Shortest path between frontend and database"

Graphify answers using only graph evidence.

Why Graphify Is Different

Most productivity tools organize files.

Most AI tools summarize files.

Graphify maps relationships between files, concepts, and systems.

That makes it fundamentally different.

It turns passive storage into active intelligence.

The Future of Knowledge Work

As people accumulate thousands of files, documents, screenshots, and code artifacts, linear search becomes insufficient.

The future belongs to systems that understand structure.

Graphify represents that shift:

From folders → graphs
From search → navigation
From notes → intelligence
From information → connected knowledge

Final Thoughts

Graphify is more than a utility—it is a new interface for thinking.

If your data is fragmented, growing, or difficult to reason about, Graphify gives you something most tools cannot:

A map of what you know—and what you didn't know was connected.

How Claude Design Could Redefine the Future of Creativity

anubhavbhatt — Mon, 20 Apr 2026 07:03:25 +0000

Anthropic has quietly entered one of the most competitive categories in tech: design software.
With the launch of Claude Design, Anthropic is signaling something bigger than a new feature. It’s making a bet that the future of design won’t begin in Figma, Photoshop, or Canva—it will begin in a conversation.

What Is Claude Design?

Claude Design is a new creative workspace from Anthropic that transforms plain-language prompts into polished visual outputs.
Users can ask Claude to create:

Product prototypes
Slide decks
Landing pages
One-pagers
Marketing assets
Branded visual materials

And Claude generates a working first draft in seconds.
Instead of dragging layers, adjusting grids, or hunting through templates, users simply describe what they want.
That shift matters.

Design Is Becoming Language-Based

For decades, design tools required technical fluency:

understanding layout systems
mastering software interfaces
knowing typography rules
navigating complex toolbars

Claude Design flips that model.

Now the skill is no longer “Can you use the software?”

It becomes:

Can you clearly explain what you want?

That’s a major unlock for founders, marketers, product managers, educators, consultants, and creators who have ideas—but not formal design training.

Why This Could Be a Big Deal

Anthropic appears to be targeting a huge gap in the market: people who need quality visuals fast, but don’t want to spend years learning professional tools.
Claude Design reportedly includes automatic brand learning, meaning it can understand company style systems and apply fonts, colors, and visual identity across outputs.
That means a startup could theoretically say:
“Create a Series A pitch deck in our brand style.”
And receive something usable within minutes.
For many teams, that changes workflow economics completely.

Final Thought

The most valuable creative skill in the next decade may not be knowing how to use design software.
It may be knowing how to think clearly, describe ideas precisely, and iterate tastefully with AI.
Claude Design is an early glimpse of that future.
And it’s worth watching.