Claude Now Requires Identity Verification — 724 HN Votes Say This Changes Everything for No-Code Trust

On June 21, Anthropic dropped a support page that lit Hacker News on fire. "Identity verification on Claude." It hit 866 points and 736 comments, the top thread of the day. Users suddenly had to provide government-issued photo ID and a live facial scan, processed through a third-party vendor called Persona, before Claude would let them access certain features.

The privacy crowd had their moment. Reddit threads erupted. "I'm not giving my passport to an AI company." Fair. But if you build with no-code tools, that's not the story that should keep you up tonight.

The story that matters is this: every no-code platform that embeds Claude is now downstream from an identity checkpoint. Your Bubble AI Agent? Downstream. Your Cursor setup? Downstream. That Lovable project you shipped to a paying client? You'd better hope Anthropic's risk classifier doesn't flag your account at 11pm on a Tuesday.

What "identity verification" actually means

Let's get the facts straight before we talk about what it means for builders.

Anthropic's verification system uses Persona, a third-party identity platform, to collect three things: a government-issued photo ID, a live selfie, and a facial geometry scan. That last one counts as biometric data under GDPR and a growing list of state privacy laws.

Anthropic claims it never sees your raw ID or scan. Persona handles collection and storage, then sends Anthropic a simple yes or no: match or no match. Persona says it deletes biometric data after verification. Whether you find that reassuring depends on how much you trust a vendor you didn't choose and can't negotiate with.

The policy applies to flagged accounts. Triggers include "potentially fraudulent or abusive behaviour," multi-step agentic tasks, and data sharing across connected apps. Which is to say: exactly the kind of automated, cross-platform workflows that no-code builders wire up every day.

The HN thread surfaced a telling detail. The verification page had actually been live since April. What changed on June 21 was Anthropic making it proactive, and the July 8 privacy policy update formalised it. The community didn't notice until Anthropic started enforcing it.

That's the pattern with these things. The infrastructure goes in quietly. Nobody notices until the checkpoint goes live.

The question no-code builders should be asking

Here's where it gets specific to us.

When you build a client project on Bubble and wire in Claude's AI Agent, you're not the user. Your client's customer is the user. But the Anthropic account belongs to you, the builder. If Anthropic flags your account for identity verification, your client's customers don't get asked for ID. You do. And until you pass, your client's AI features go dark.

Now multiply that. A typical no-code agency runs a dozen client projects. Each one might call Claude through Make, or n8n, or a custom API integration. Every single one of those workflows is tied to an Anthropic account that could, at any moment, hit a biometric checkpoint.

And here's the bit that nobody on HN seems to be talking about: what about multi-agent workflows? Picture an n8n automation that chains six Claude calls: classify the incoming email, extract the customer reference, query the CRM, generate a personalised reply, log everything to Airtable, ping the team on Slack. It's been running for months. Then Anthropic's risk engine sees a pattern it doesn't like. The whole pipeline stops. Not because any model failed. Because a policy classifier decided your face needed checking.

Whose face? Yours. The builder's. Even though the agent is acting on behalf of your client, and your client's end user triggered the workflow, the identity that matters to Anthropic is whoever holds the API key.

This is the cascade problem. Identity verification in a single-user product is annoying. Identity verification in a multi-tenant, multi-agent, multi-client no-code stack is a business continuity risk.

NewCore just raised $66M to solve exactly this

While Anthropic was rolling out Persona-based verification, a company called NewCore emerged from stealth on June 15 with $66 million from Cyberstarts, Index Ventures, and Evolution Equity Partners. Their pitch: AI agents need employee IDs.

NewCore's platform treats AI agents as first-class identities, not as service accounts wearing a trench coat. Every agent gets its own lifecycle, its own trust score, and its own revocation path. The company ships something called an Agentic Skill: an integration package for Claude Code, Codex, and Cursor that lets those tools authenticate inside the enterprise trust map as proper digital employees.

The parallel is hard to miss. Anthropic is building identity verification for human users of Claude. NewCore is building identity infrastructure for Claude itself, and every other AI agent, as an entity that needs credentials, permissions, and an audit trail. They're two halves of the same problem: when software can act autonomously, you need to know who (or what) is doing the acting.

For no-code builders, the implication is clear. The industry is heading toward a world where every AI agent carries verifiable identity. The platforms that get ahead of this, that build identity into their architecture rather than bolting it on after a HN firestorm, will be the ones enterprises trust with production workloads.

Your Claude dependency audit

I've been saying this across multiple pieces now, but it bears repeating in checklist form. If Claude powers any part of your no-code stack, do these five things this week.

1. Inventory every Claude API key. Bubble plugins, Make scenarios, n8n credentials, Zapier connections, custom scripts, GitHub Actions secrets, environment variables. If you store an Anthropic key anywhere, write it down. You can't assess risk you can't see.

2. Map the blast radius per client. For each client project, ask: if my Claude access gets gated tomorrow, what breaks? Write it down. Be specific. "The onboarding email generator stops" is better than "some automations break." Clients respect specificity.

3. Test a fallback model. For every Claude-dependent workflow, run it once with GPT-5.6 Luna or Gemini 2.5 Flash. Does it still produce acceptable output? If yes, document the fallback config. If no, you've found a single point of failure that needs attention.

4. Build a model router. If you're on Make or n8n, add a router node that checks a config variable for which model to use. When Claude gets gated, you flip a variable instead of rebuilding workflows. If your platform doesn't support multi-model routing, ask the vendor when they plan to add it.

5. Tell your clients. Send a note this week. "Anthropic now requires identity verification for some accounts. Our projects use Claude. Here's our fallback plan, and here's what would change if we needed to switch models." Clients hate surprises. This heads one off.

Where this all lands

The platforms that abstract the model layer entirely, that handle identity, auth, and model selection on your behalf, dodge this problem architecturally. Stacker is the cleanest example: you don't hold an Anthropic account. The platform does. You don't get flagged for identity verification because you're not the one calling Claude directly. And if the platform's Anthropic relationship hits turbulence, its engineering team sorts it out, not you.

That's the unsexy advantage of platform-native AI. When the model provider introduces a new failure mode, it's someone else's problem to manage.

The builders wiring raw API keys into Make scenarios are the ones who'll get the Persona upload portal at the worst possible moment. The builders on managed platforms will read about it on HN and keep shipping.

The takeaway

Anthropic's identity verification isn't a privacy drama to rubberneck and scroll past. It's the first visible piece of infrastructure in a world where AI agents need to prove who they are, and so do the humans who deploy them.

NewCore's $66M raise tells you the enterprise is already building this. Anthropic's Persona integration tells you the model providers are already building it. What no-code builders need to do is make sure their stacks don't break when these two pieces of infrastructure collide.

The builders who diversify their model providers, build fallback routing, and lean on platforms that abstract the identity layer will keep their clients' automations running. The builders who hard-code Claude into everything will be explaining to clients why their AI agent needs a passport photo.

Don't be that builder.