Forem: 정상록

OmniVoice: Open-Source TTS with 600+ Languages and Zero-Shot Voice Cloning

정상록 — Tue, 21 Apr 2026 02:32:49 +0000

OmniVoice: Open-Source TTS with 600+ Languages and Zero-Shot Voice Cloning

The TTS landscape just shifted. On March 31, 2026, the k2-fsa team — the same group behind Kaldi and k2, with Daniel Povey as a core contributor — released OmniVoice: an Apache 2.0 licensed TTS model supporting 600+ languages zero-shot, with 40x real-time inference speed.

In just three weeks, it hit 3,775 GitHub stars and 460,000+ HuggingFace downloads. Here's why developers are paying attention and how to run it locally.

The Numbers That Matter

Metric	Value
Languages supported	600+ (zero-shot)
RTF (Real-Time Factor)	0.025 (40x faster than real-time)
License	Apache 2.0 (commercial use OK)
Base model	Qwen3-0.6B
Reference audio needed	3–10 seconds (or none)
Hardware	Runs on consumer GPUs, Apple Silicon MPS supported

Compare this to commercial services:

ElevenLabs Pro: $22/month, limited characters
ElevenLabs Business: $99/month
Azure TTS: $16/million characters
Google Cloud TTS: $16/million characters

OmniVoice: zero cost after deployment. Unlimited usage on your own hardware.

Three Modes in One Model

OmniVoice supports three inference modes through a single unified API:

1. Voice Cloning

Clone a voice from a short reference audio clip. Whisper auto-transcribes the reference text if you don't provide it.

from omnivoice import OmniVoice
import soundfile as sf
import torch

model = OmniVoice.from_pretrained(
    "k2-fsa/OmniVoice",
    device_map="cuda:0",
    dtype=torch.float16,
)

audio = model.generate(
    text="This voice was cloned from a 3-second reference.",
    ref_audio="ref.wav",
    # ref_text optional - Whisper auto-transcribes
)

sf.write("cloned.wav", audio[0], 24000)

2. Voice Design

Design a voice from scratch using natural language attributes. No reference audio required.

audio = model.generate(
    text="This is a designed voice.",
    instruct="female, low pitch, british accent",
)

Combine attributes freely: gender, age, pitch, speech speed, accent, dialect, emotional tone.

3. Auto Voice

No voice prompt at all. Fastest mode for quick prototyping.

audio = model.generate(text="Quick test output.")

Installation

PyTorch must be installed first, with version pinned to 2.8.0.

# NVIDIA (CUDA 12.8)
pip install torch==2.8.0+cu128 torchaudio==2.8.0+cu128 \
    --extra-index-url https://download.pytorch.org/whl/cu128

# Apple Silicon (M1/M2/M3)
pip install torch==2.8.0 torchaudio==2.8.0

# OmniVoice
pip install omnivoice

Verify GPU/MPS detection:

import torch
print("CUDA:", torch.cuda.is_available())
print("MPS:", torch.backends.mps.is_available())

Fast Path: Web Demo

The fastest way to validate your setup is the bundled Gradio demo.

omnivoice-demo --ip 0.0.0.0 --port 8001

Navigate to http://localhost:8001 and test all three modes through a UI.

CLI Tools

Besides the Python API, OmniVoice ships with two CLI tools:

# Single inference
omnivoice-infer --model k2-fsa/OmniVoice \
    --text "Hello world." \
    --ref_audio ref.wav \
    --output hello.wav

# Multi-GPU batch inference
omnivoice-infer-batch --model k2-fsa/OmniVoice \
    --test_list test.jsonl \
    --res_dir results/

Batch format (JSONL):

{"id": "clip_001", "text": "First clip.", "ref_audio": "ref.wav"}
{"id": "clip_002", "text": "Second clip.", "ref_audio": "ref.wav"}

Perfect for audiobook generation or large-scale narration pipelines.

Expression Control with Inline Tokens

Drop non-verbal tokens anywhere in the text:

text = "That's hilarious [laughter] but also a bit concerning [sigh]."
audio = model.generate(text=text, ref_audio="ref.wav")

Available tags include [laughter], [sigh], [question-ah], [surprise-wa].

Pronunciation Override

For homophones and proper nouns, override pronunciation directly.

English (CMU notation)

# "bass" as musical instrument, not low-frequency sound
audio = model.generate(text="He plays [B EY1 S] guitar.")

Chinese (Pinyin with tone numbers)

# Force specific tone
audio = model.generate(text="打ZHE2")

Architecture Notes

OmniVoice uses a Diffusion Language Model hybrid architecture. It's neither pure diffusion nor pure autoregressive — it combines the quality benefits of diffusion with the speed advantages of LLM-style generation. The base model is Qwen3-0.6B, making it light enough for consumer hardware while leveraging the language understanding of a modern LLM.

This is a different direction from previous open-source TTS projects (Bark, XTTS, F5-TTS), and it seems to be paying off in both quality and inference speed.

Production Tips from Issue #44

The community has been active on GitHub Issue #44 discussing real-world usage.

Voice Design consistency. Each call produces slightly different timbre. Generate once, save the output, then reuse as ref_audio to lock in a consistent voice for an entire project.

Prompt caching. Use create_voice_clone_prompt to precompute reference audio encodings once, then reuse the cached prompt for repeated generation. Critical for throughput on long-form content.

Number normalization. Raw digits like "123" can produce inconsistent output. Normalize to words ("one hundred twenty-three") using WeTextProcessing or similar before passing text to the model.

Cross-lingual accent bleed. If you use a Korean reference to generate English, the output has a Korean accent. For neutral target language accent, use native-speaker references.

Who This Is For

OmniVoice fits several developer profiles well:

Solo developers and indie hackers who were paying commercial TTS subscriptions just for hobby projects
AI agent builders needing voice output without vendor lock-in
Content creators doing multilingual localization (YouTube, podcasts)
Voice cloning experiments where 3-second references unlock a lot of creative possibilities
Low-resource language applications (the 600+ language coverage includes many languages with no good commercial option)

What's Next

The k2-fsa ecosystem has a strong track record of long-term maintenance (Kaldi is still actively used 15+ years after release). That matters when you're deciding whether to build production infrastructure on a new model.

If you're evaluating TTS options, OmniVoice deserves a spot in the comparison. The combination of 600+ language support, 40x real-time inference, and Apache 2.0 licensing is genuinely rare in open source TTS today.

Resources

Have you tried OmniVoice yet? Would love to hear how it compares to your current TTS setup in the comments.

chrome-devtools-mcp: Google's Official MCP Server That Lets AI Agents Drive Chrome DevTools

정상록 — Tue, 21 Apr 2026 02:26:07 +0000

chrome-devtools-mcp: Google's Official MCP Server That Lets AI Agents Drive Chrome DevTools

If you're using Claude Code, Cursor, or any MCP-capable AI agent for frontend work, there's now an official way to let your agent drive Chrome directly — and it's maintained by Google's Chrome DevTools team.

The package is called chrome-devtools-mcp, it's Apache-2.0 licensed, and as of April 2026 it's at v0.21.0 after 43 releases in 7 months. This isn't a one-off experiment — Chrome team is shipping it on a roughly weekly cadence.

Here's what changed for me after installing it, and what you need to know before doing the same.

TL;DR

Official Google MCP server wrapping Chrome DevTools via Puppeteer
29 tools across 7 categories (input, navigation, performance, network, debugging, emulation, memory)
One-line install for Claude Code: claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest
Chrome M144+ ships --autoConnect — AI attaches to your already-running Chrome session (keeps logins, cookies, extensions)
Not a Playwright MCP replacement. Different use case (live debugging vs deterministic E2E tests)
Security-sensitive: browser content is shared with your MCP client; disable telemetry with CI=1

What it actually does

Before chrome-devtools-mcp, asking an AI agent to debug a web page meant a lot of manual copy-pasting. You'd screenshot the Network tab, paste console errors as strings, describe what you see. The AI was always one abstraction layer away from the actual browser state.

With the MCP server installed, your agent can:

Navigate pages (navigate_page, new_page, multi-tab control)
Click, type, drag, fill forms (click, fill_form, upload_file, press_key)
Read the actual DevTools Performance trace (performance_start_trace, performance_analyze_insight)
Execute Lighthouse audits (lighthouse_audit) — including CrUX real-user data
Inspect every HTTP request natively, not via screenshot (list_network_requests, get_network_request)
Read console messages with sourcemap-resolved stack traces (list_console_messages)
Take memory heap snapshots for leak hunting (take_memory_snapshot)

The full list is 29 tools, all surfaced via the standard MCP protocol. Any agent that speaks MCP — Claude Code, Cursor, Cline, Zed, Gemini CLI — can use them identically.

Installation

Method 1: MCP server only

claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest

--scope user makes it available across all your Claude Code projects. Use --scope project to limit to the current workspace.

Method 2: Plugin (MCP + Skills)

/plugin marketplace add ChromeDevTools/chrome-devtools-mcp
/plugin install chrome-devtools-mcp

The plugin bundle adds Chrome-curated Skills (prompt presets) alongside the MCP server. Higher-level commands like "run a performance audit" just work.

Requirements

Node.js v20.19 or newer (LTS)
Chrome Stable (M144+ recommended for --autoConnect)
npm (comes with Node)

After installing, restart Claude Code and run /mcp to verify chrome-devtools (29 tools available) is listed.

The feature that changed my workflow: `--autoConnect`

Chrome M144 (December 2025) added support for --autoConnect. Instead of spawning a fresh Chrome instance every time, the MCP server attaches to your existing Chrome via remote debugging.

# 1. Start Chrome with remote debugging enabled
open -a "Google Chrome" --args --remote-debugging-port=9222

# 2. Register MCP pointing at it
claude mcp add chrome-devtools-live --scope local \
  npx chrome-devtools-mcp@latest --autoConnect

Why this matters: your existing browser state — SSO sessions, extensions, developer tools panel position, the exact tab you were debugging — is preserved. You can manually reproduce an issue, hand off to AI mid-session, and the AI sees the same DOM you see.

Playwright MCP doesn't do this. Playwright is intentionally designed for test isolation, spawning fresh contexts. Different philosophy, different use case.

chrome-devtools-mcp vs Playwright MCP

This is the question that comes up every time.

Concern	chrome-devtools-mcp	Playwright MCP
Primary purpose	Live debugging, performance audits	Deterministic E2E tests
Browser support	Chrome only	Chrome / Firefox / WebKit
Performance tracing	Native	Not supported
Lighthouse audit	Built in	Not supported
CrUX real-user data	Yes	No
Test isolation	Weak (by design)	Strong
CI/CD fit	Moderate	Excellent

Rule of thumb: writing regression tests → Playwright MCP. Debugging why production is slow or a specific user hits an error → chrome-devtools-mcp. Most teams benefit from having both installed.

Real-world workflow examples

Weekly performance audit

Every Monday, for these 5 landing pages:
1. Run Lighthouse audit (mobile and desktop)
2. Compare Core Web Vitals (LCP, CLS, INP) to last week's numbers
3. Flag any score regressions > 5 points
4. Diagnose the root cause in the network waterfall
5. Output a markdown report

This used to be a 2-hour manual process. Now it's a 10-minute async handoff.

Pre-deploy smoke test

On localhost:3000:
1. Load home page — fail if any console errors
2. Complete signup form — fail if not redirected to onboarding
3. Authenticate and load dashboard — fail if any 4xx/5xx requests
4. Screenshot each step
5. Bail with error analysis on first failure

Production incident triage

With --autoConnect attached to your logged-in Chrome, you can say "reproduce the bug the customer reported on /app/settings" and the AI navigates there, clicks through, captures console + network, and returns the sourcemap-resolved stack trace.

Useful flags

--slim — reduces the tool surface to 3 essentials (navigate, click, snapshot). Saves MCP tokens when you don't need the full kit.
--isolated — runs in an isolated Chrome profile, doesn't touch your personal session.
--headless — for CI/CD.
--browserUrl http://localhost:9222 — explicit version of --autoConnect.
--channel beta|canary|dev — target a non-Stable Chrome channel.
--no-usage-statistics — opt out of Google telemetry (also respects CI=1).
--no-performance-crux — skip CrUX real-user data lookups.

Security caveats (do not skip)

1. Browser content is sent to your MCP client.

Anything rendered in the browser — DOM, cookies, localStorage — can end up in your AI model's context. Do not run DevTools MCP on tabs where you're logged into a bank, an internal admin panel, or anything with sensitive PII, unless you're comfortable with that data reaching your model API provider.

Mitigation: use --isolated to separate from your personal profile, or start Chrome with a dedicated profile argument.

2. Telemetry is on by default.

Google collects anonymized usage statistics. If that's not acceptable for your compliance requirements, set CI=1 in your shell env or append --no-usage-statistics.

3. Remote debugging port must be localhost-bound.

--autoConnect works by connecting to Chrome's remote debugging port (default 9222). If that port is exposed to your LAN or a public IP, anyone on the network can read your browser state or execute scripts in your session.

Verify binding with:

lsof -i :9222

You want to see 127.0.0.1:9222 or localhost:9222, never 0.0.0.0:9222. On shared networks, avoid the port-based flow entirely and let MCP spawn its own isolated Chrome.

FAQ

Does it work with Chromium forks like Edge, Brave, Arc?

Officially Chrome Stable only. Chromium-based browsers may work for basic cases but performance-analysis tools can be unreliable.

Is the Lighthouse audit slower than CLI Lighthouse?

A bit — you're paying the AI round-trip cost. If you only need raw scores, stick with CLI Lighthouse. If you want scores + root-cause analysis + a fix, the MCP path saves time overall.

Is it free?

Yes. Apache-2.0 open source, Google-maintained. No API keys, no subscription.

Verdict

If you use an MCP-capable AI agent for frontend work and you haven't installed chrome-devtools-mcp yet, you're leaving the single highest-leverage automation on the table. The install is five minutes, the learning curve is shallow, and the maintainer is the Chrome team itself.

The workflows that save the most time for me: weekly Lighthouse audits with regression diagnosis, pre-deploy smoke tests, and production incident triage with --autoConnect. If any of those land in your week, DevTools MCP is a straightforward win.

References

Official repo: github.com/ChromeDevTools/chrome-devtools-mcp
npm package: npmjs.com/package/chrome-devtools-mcp
Chrome DevTools AI Agents docs: developer.chrome.com/docs/devtools/agents
Announcement blog post: developer.chrome.com/blog/chrome-devtools-mcp
--autoConnect walkthrough: developer.chrome.com/blog/chrome-devtools-mcp-debug-your-browser-session

Claude Cowork Goes GA — Why Live Artifacts Change How We Work With AI

정상록 — Tue, 21 Apr 2026 02:19:16 +0000

On April 9, 2026, Anthropic released Claude Cowork to every paid plan — Pro, Max, Team, Enterprise. It started as a macOS-only research preview for Max users on January 12. Three months later, it's everywhere. And the real headline isn't the rollout. It's Live Artifacts.

What Cowork Actually Is

Claude Cowork is not just another desktop app. Anthropic defines it as a "collaborative workspace where Claude performs long-running tasks in the background while exchanging results with the user in real time."

The difference from regular Claude.ai chat:

Dimension	Claude Chat	Claude Cowork
Interaction	Turn-based Q&A	Background long-running execution
Output	Text + static artifacts	Live artifacts + progress state
Context	Per-session	Persistent per Project
Integrations	Optional MCP	Zoom, Excel, PowerPoint, Slack built-in
Plan	All tiers	Paid plans only

Why now? OpenAI's Agent Mode and Google's Gemini Deep Research pushed the industry into "long-horizon autonomous AI" in Q1 2026. Anthropic responded — but with a twist. Instead of "let AI handle it alone," they chose "let AI handle it beside you."

Why Live Artifacts Matter

Artifacts themselves shipped in August 2024. Nothing new there. The shift to Live Artifacts has three real implications:

1. You see state changes as they happen

When Claude runs a 10-minute task, you used to wait for the final output. Now the dashboard fills up, charts draw themselves, data streams into the artifact panel — all in real time.

This isn't a UX polish. It means you can course-correct mid-execution. "Actually, make that a bar chart instead" works.

2. Artifacts run in isolated VMs

The Cowork artifact sandbox is an isolated VM that actually executes React components, Python scripts, and interactive HTML. When you ask for a dashboard, Claude generates the code and the running dashboard appears simultaneously. Click a button, it responds. Change a filter, the chart updates.

3. MCP integrations pipe real data in

The Zoom MCP connector ships built-in. Meeting recordings, summaries, and action items flow straight into Live Artifacts. Excel and PowerPoint get end-to-end integration — upload a file, Claude's edits land back in the original.

The Timeline That Got Us Here

Jan 12  — Research preview (macOS + Max only)
Feb 10  — Windows support
Feb 24  — Plugin marketplace + Excel/PPT + Slack
Mar 20  — Projects integration
Mar 23  — Dispatch (assign from phone, execute on desktop)
Apr 8   — Enterprise deployment announcement
Apr 9   — General availability + enterprise governance

Three months, three expansion axes: platforms (Mac → Windows), features (plugins → Projects → Dispatch), and distribution (Max → all paid).

What the April 9 GA Actually Added

Beyond rollout, this release brought enterprise-grade governance down to the Pro plan:

Role-based access control (RBAC): Scope Cowork features per team member. Sensitive projects stay locked to specific roles.

Group spend limits: Set API usage caps per team or project. Budget blowups get harder.

OpenTelemetry observability: Cowork activity logs export in standard telemetry format. Plug into Datadog, New Relic, whatever you use. Essential for audit requirements.

Analytics API: Query Cowork usage patterns programmatically. Which team uses what, how often, in measurable terms.

Zoom MCP connector: Automatic meeting data pipeline.

The key point: this stack is available on the $20/month Pro plan. Enterprise-tier governance for solo operators.

Solo Operator Playbook

If you're a one-person shop wearing multiple hats (I run Quantum Jump Club as CEO + marketer + developer + accountant), Cowork changes the math.

Pattern 1: Projects per Role

Split Cowork Projects by job function:

"Content" Project: Blog, social, YouTube scripts
"Finance" Project: Revenue analysis, expense processing, budget monitoring
"CRM" Project: Lead analysis, pipeline management, customer research
"Product" Project: Curriculum design, VOD planning

Each Project keeps its own context. Step into "Content" and Claude already knows your brand voice, past content style, and target audience.

Pattern 2: Live Artifacts for Numerical Decisions

Monday morning: upload revenue Excel, ask "analyze vs last week + suggest 3 focus metrics this week."

In the artifact panel:

Dashboard fills in real time
KPI cards flag warnings by color
What-if sliders generate themselves

Drag the slider and ask "what if ad spend goes up 20%?" The AI partner runs it with you.

Pattern 3: Meeting-to-Action Pipeline

Zoom a customer call. Zoom MCP connector auto-pipes recording/transcript/summary into Cowork. Cowork extracts action items and renders them as a live checklist artifact. Within 30 seconds of meeting end, "who does what" is visualized.

Different from classic meeting automation — output arrives in an executable form, not just text.

Honest Limitations

Network restrictions

The artifact sandbox is an isolated VM with restricted outbound network. GitHub issue #46243 (April 10, 2026) flags that video/audio/HLS streaming gets blocked. Anthropic confirmed this is intentional for security. Real-time media rendering use cases remain constrained.

Memory scope

Context persists within a Project but doesn't cross Projects. If you want Project A's knowledge in Project B, you transfer it manually.

Desktop only

Mobile supports Dispatch (task assignment) but actual Cowork execution is desktop. Field work remains limited.

Cost structure

Cowork is available on Pro ($20/mo) but Live Artifacts burn tokens fast. Run long sessions often and you'll hit the monthly cap. Max ($100/mo) is more realistic for mission-critical use.

Getting Started in 5 Minutes

Update Claude Desktop to latest (macOS: Cmd+Q restart; Windows: Settings > Check for Updates)
Confirm Pro plan or higher
Click the Cowork tab in the left sidebar (enable in Settings > Features if missing)
Create a new Project organized by role
Drag an Excel file in
Ask: "build a live dashboard from this data"
Watch the artifact panel come alive

That's the moment the phrase "working through a chat window" starts feeling weird.

Bottom Line

Claude Cowork's Live Artifact update isn't a feature drop. It's a shift in how we work with AI. Chat is conversation. Cowork is collaboration.

While OpenAI and Google race on autonomy, Anthropic bet on the collaborative experience. For solo operators, that bet pays off — the "Excel analyst + deck designer + action-item secretary" combo is now $100/month away.

Update your Claude Desktop and open the Cowork tab. Five minutes is enough to see the shift.

References:

Claude Design Launch — How Anthropic Made Figma's Stock Drop 7% in One Day

정상록 — Mon, 20 Apr 2026 11:31:09 +0000

Claude Design Launch — How Anthropic Made Figma's Stock Drop 7% in One Day

On April 17, 2026, Anthropic shipped Claude Design — a research preview that turns natural-language prompts into presentations, UI prototypes, and marketing one-pagers. Figma's stock dropped about 7% the same day.

I've been poking at it for the last 48 hours. Here's what actually matters for devs and founders.

TL;DR for Engineers

Property	Value
Release	2026-04-17, Anthropic Labs
Model	Claude Opus 4.7
Render engine	Canva Design Engine (partnership)
Access	Claude Pro / Max / Team / Enterprise
Killer feature	One-shot handoff to Claude Code
Exports	PDF, PPTX, HTML, Canva, org URL, code bundle

The Five Features That Matter

1. Prompt → Visual in ~30 seconds

"SaaS landing page, dark mode, hero with 2 CTAs,
3-tier pricing table, customer logo strip"

Claude Opus 4.7 plans the structure, Canva's engine renders. Editable output in 30 seconds.

2. Interactive inline edits

Not "regenerate the whole thing." Three tools work in parallel:

Inline comments ("more restrained tone here")
Direct editing (text, colors, sizing)
Custom sliders (spacing, contrast, font weight)

This is the Figma/Canva UX ported to AI. It's the reason I think Claude Design has staying power where previous AI design tools failed.

3. Team design system ingestion

This is the enterprise unlock. During onboarding you point Claude at:

GitHub repo (it parses tailwind.config.js, CSS variables)
Figma library URL
Brand guide PDF

Claude extracts color palette, typography, spacing rules, component patterns. All subsequent generations use your tokens. No more pasting hex codes into every prompt.

4. Claude Code handoff

The differentiator that Figma doesn't have:

/handoff --to claude-code --format nextjs --styling tailwind

Claude Design ships a bundle (design intent + structure + tokens) to Claude Code, which generates production Next.js / React / Vue. The loop closes inside Anthropic's ecosystem.

5. Multi-format export

PDF (investors), PPTX (existing slide workflows), HTML (preview), organization URL (team review), Canva (fine-tuning), Claude Code (production).

How to Actually Use It — 6 Steps

Confirm Claude Pro+ subscription
Click the palette icon (🎨) in left nav on claude.ai
(Optional, Team/Enterprise) Connect codebase + design system during onboarding
Write a structured prompt (see pattern below)
Iterate with inline comments / sliders
Export or handoff to Claude Code

Prompt pattern that actually works

Five elements, in order:

1. Output type (landing, pitch deck, UI, one-pager)
2. Core structure (N sections, ordering)
3. Style (tone, color palette, reference brand)
4. Content (actual text, numbers, names)
5. Constraints (length, fonts, banned elements)

Bad prompt: "nice landing page"

Good prompt:

B2B SaaS landing page, 1 page. Sections: (1) hero with headline
"AI automates your bookkeeping", 1-line sub, CTAs "14-day free trial"
and "Book demo"; (2) logo strip (6 logos, Notion/Linear/Figma style);
(3) 3 value props with icon + 1-liner; (4) 1 screenshot;
(5) 3-tier pricing $29/99/299; (6) 4-question FAQ; (7) footer.
Style: Linear aesthetic, dark mode, restrained typography,
NO diagonal glass effects, NO accent bars.

Why Figma Stock Dropped

Not because designers are obsolete. Because the "explore what to build" step — the one where founders traditionally bring wireframes to designers — just got 100x faster.

Designers still win on:

Auto Layout precision
Design critique and iteration
Systems thinking
Dev Mode handoff to existing codebases

But the pre-designer exploration phase just got eaten. Founders walk into meetings with prototypes, not wireframes. PMs ship specs as working screens, not PowerPoints.

The Honest Part — What r/ClaudeAI Complains About

Reddit found the pattern fast:

Homogeneous output — serif fonts, blinking status dots, color accent bars, "container soup" card layouts. Generated outputs scream "made with Claude Design."
Customization ceiling — without reference screenshots or design tokens, you can't escape the preset aesthetic.
Stock reaction hype — some analysts argue the 7% drop reflects AI-disruption anxiety more than actual competitive threat. Figma is still vastly more capable per hour of work.

Workarounds I've Found

Attach 3–5 reference screenshots of brands you want to emulate (Linear, Superhuman, Stripe)
Negative prompts work: "NO: serif fonts, blinking dots, accent bars, overlapping cards"
Use it as first draft, then hand off to designer or Canva for final polish
Replace default fonts in the generated HTML before export

Competitive Landscape for Devs

Tool	When to pick
Claude Design	Founder/PM draft → Claude Code production
Figma	Designer-led team, fine-grained control
Vercel v0	Single React component, fast
Lovable / Bolt.new	Skip design, go straight to working app
Canva	Marketing SNS, printed assets

If you're already in the Anthropic ecosystem (Claude Code user), the handoff alone justifies Claude Design. The friction between "here's what I want" and "here's working code" drops significantly.

My Take

The pattern I see repeatedly with AI tools is: they don't replace the craft, they eat the pre-craft exploration. Claude Code didn't replace developers — it ate the "boilerplate and first-pass implementation" phase. Claude Design doesn't replace designers — it eats the "what should this even look like" phase.

If you're a founder: ship this week. Drafts that took 3 days now take 30 seconds.

If you're a designer: the scarcity shifts from "creating options" to "judging and refining options." Your leverage goes up, not down, if you adapt.

If you're an engineer: the handoff from Claude Design to Claude Code is the interesting part. Test whether your team can actually ship production-quality code from the bundle. I'd bet it's 70% there today and 95% in six months.

Resources

Curious what other Dev.to folks think — are you shipping with this already, or waiting for the kinks to shake out?

Claude Code Advisor: Opus Steering Sonnet Inside a Single API Call

정상록 — Mon, 20 Apr 2026 03:19:24 +0000

Claude Code Advisor: Opus Steering Sonnet Inside a Single API Call

Anthropic shipped the Advisor Strategy on April 9, 2026. It's not a new model. It's a pattern: a fast executor (Haiku/Sonnet) does the work, and at decision points it calls a stronger advisor (Opus) for strategic guidance — all inside a single /v1/messages request, handled server-side.

The numbers are the headline.

The Benchmark Story

SWE-bench Multilingual (real coding tasks):

Sonnet 4.6 solo: 72.1%
Sonnet 4.6 + Opus advisor: 74.8% (+2.7pp)
Cost: 11.9% cheaper (yes, higher quality and cheaper)

BrowseComp (web research):

Haiku 4.5 solo: 19.7%
Haiku 4.5 + Opus advisor: 41.2% (2x+)
Cost: 85% cheaper than Sonnet solo

That last one is the jaw-dropper. You get Haiku latency, Opus judgment, and a price point below Sonnet.

How It Works

The Advisor is server-side. From the client's perspective, it's just another tool in the tools array:

from anthropic import Anthropic

client = Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",  # executor
    max_tokens=4096,
    tools=[
        {
            "type": "advisor_20260301",
            "model": "claude-opus-4-7",  # must be >= executor
            "max_uses": 5,
            "caching": {"type": "ephemeral", "ttl": "5m"}
        }
    ],
    extra_headers={
        "anthropic-beta": "advisor-tool-2026-03-01"
    },
    messages=[{"role": "user", "content": "Refactor the payment module."}]
)

# Per-call token breakdown in usage.iterations[]
for it in response.usage.iterations:
    print(it.model, it.input_tokens, it.output_tokens)

What happens internally:

Executor emits a server_tool_use block (name="advisor", input={})
Anthropic's server forwards current context to the advisor
Advisor (Opus 4.7) runs extended thinking, returns guidance
An advisor_tool_result block lands in the stream
Executor continues

The advisor does not call tools. The advisor does not respond to the user. It only whispers strategy to the executor.

When to Call the Advisor

Anthropic's official prompting guide says four moments:

Before substantive work — before writing, before committing to an interpretation
When the task feels complete — but persist the deliverable first
When stuck — same error recurring, approach not converging
When considering a change of approach

What not to call it for: pure mechanical work, single-turn Q&A, workloads that need top-tier intelligence on every turn.

The Trimming Trick

Add this line to your system prompt:

"The advisor should respond in under 100 words and use enumerated steps, not explanations."

Per Anthropic's own measurements: 35-45% token reduction on advisor calls with no quality degradation. Pair it with max_uses to cap per-request spend.

Claude Code Users: One Command

If you're using Claude Code CLI, skip the SDK entirely:

/advisor

That's it. The toggle flips, and every subsequent agent loop uses the Executor-Advisor pattern.

Error Codes to Know

Code	Cause	Fix
`max_uses_exceeded`	Per-request cap hit	Raise `max_uses` or tighten executor prompt
`overloaded`	Advisor capacity	Retry with backoff, fallback to Opus 4.6
`context_mismatch`	You stripped `advisor_tool_result` blocks	Keep full assistant response in multi-turn
`invalid_advisor_model`	Advisor weaker than executor	Always use Opus 4.7 as advisor

Customer Evidence

Bolt (Eric Simmons, CEO): "Architectural decisions on complex tasks visibly improved. The plans and trajectories are completely different."
Eve Legal (Anuraj Pandey): "Haiku 4.5 with Opus 4.6 advisory hit frontier quality at 5x less cost on structured document extraction."

The Takeaway for Indie Developers

The model-selection dilemma — "Opus quality but at Haiku prices" — just got structurally solved. If you're running long-horizon coding agents, multi-step research pipelines, or Computer Use flows, this pattern changes your cost curve.

Three lines of code to try it. One CLI command if you're in Claude Code.

Reference: Anthropic Blog — The Advisor Strategy

OpenAI 'Spud' (Rumored GPT-5.5 Pro): What Employees Are Saying, What We Actually Know

정상록 — Mon, 20 Apr 2026 03:18:37 +0000

Pre-read disclaimer: Most of what follows is pre-release rumor and speculation. "GPT-5.5 Pro" is a community-coined name, not an officially confirmed product. Benchmark numbers, release dates, and architectural details below are unverified. Treat this as an informed signal analysis, not confirmed fact.

TL;DR

OpenAI finished pretraining its next frontier model on March 24, 2026. Internal codename: Spud. Official branding is TBD — the community has been calling it "GPT-5.5" or "GPT-6" depending on how well it benchmarks. "Pro" is a community assumption.

The interesting part isn't the technical rumors. It's the language pattern. Greg Brockman called it "the big model feel" — the exact phrase OpenAI employees internally used for the GPT-3 → GPT-4 jump. Multiple employees are saying "different from anything before." That's unusual.

For devs, the one practical thing to know: Spud is rumored to have native multi-modality at the architecture level. If you have pipelines where image → text description → LLM, consider refactoring to a unified context now. That design pattern may become obsolete soon.

What Actually Happened on March 24, 2026

The Information broke the story: OpenAI completed pretraining of the next model. Key facts:

Fact	Source confidence
Codename "Spud"	High (multiple corroborating reports)
Training at Stargate (Abilene, TX)	High (publicly known facility)
Currently in RLHF + red team	High (standard OpenAI pipeline)
Target release in "a few weeks"	High (Altman direct quote)
Official name "GPT-5.5" or "GPT-6"	Low (depends on benchmarks)
Suffix "Pro"	Very low (community speculation)

The interesting phrasing choices:

Sam Altman: "A very strong model that could really accelerate the economy."

He didn't use "accelerate the economy" for GPT-4. Unusual word choice from a CEO who is normally measured.

Greg Brockman: "There are two years of research inside this model. It has a big model feel — it's not an incremental improvement, it's a significant change in the way we think about model development."

This is the one that matters. "Big model feel" is not marketing copy. It's internal OpenAI vernacular from the GPT-3 → GPT-4 transition. Brockman using this phrase publicly is a signal choice.

The Employee Leak Pattern

What makes this different from typical hype cycles: multiple employees using the same phrasing in independent channels.

"very different from what we've seen before"
"not just bigger"
"changes how I think about what's possible"

One employee expressing excitement means nothing. A dozen using the same language suggests a shared internal framing. That's the current pattern.

The LM Arena Anomaly

Early April, three anonymous models appeared on LM Arena for a few hours and got yanked:

maskingtape-alpha
gaffertape-alpha
packingtape-alpha

All tape-related names. Same test family, almost certainly. Community consensus:

One is likely the new image model (GPT-Image-2, which OpenAI subsequently shipped)
The other two are text/multimodal variants of Spud
They got pulled because someone internally noticed live testing leaked to a public benchmark

April 19: Multiple prod API users reported response patterns that didn't match GPT-5.4's behavior. Could be "limited live testing" of Spud.

The Benchmark Picture

This is where it gets strategic. SWE-bench Pro (code agent capability) is the benchmark that matters for enterprise AI spend in 2026:

Model	SWE-bench Pro	Released
GPT-5.4 (OpenAI current)	57.70%	Public
Claude Mythos (Anthropic)	77.80%	Public
Spud (estimate)	high 70s to 80s	Internal

OpenAI is ~20 percentage points behind Anthropic on coding agent tasks right now. In enterprise AI procurement, this kind of gap is causing actual customer migrations. Anthropic has been gaining ground fast on dev tooling specifically.

So the question isn't just "how good is Spud?" It's "does Spud close or exceed the Anthropic gap?" The community thinks that's the difference between "GPT-5.5" branding (close but not ahead) and "GPT-6" branding (clearly ahead).

What's Rumored to Be Architecturally Different

Native multi-modality. That's the headline leak.

Current approach (GPT-5.4):

[user sends image + text]
       ↓
Vision module → converts image to text description
Text module → combines with original text  
       ↓
LLM → generates response

Spud approach (rumored):

[user sends image + audio + text]
       ↓
Unified transformer (same blocks handle all modalities natively)
       ↓
Response (possibly multimodal output)

If this is real, the implications for developers:

Pipeline architectures become obsolete. If you built a multimodal app that routes image → description → LLM, that's going to be dead weight.
Tool use quality should improve. Native multimodality + longer agentic context handles complex 14+ step workflows better (this is the specific gap vs Claude Mythos).
Latency drops. No inter-module routing overhead.

Practical recommendation: if you're building agentic systems right now, design your context as a single unified stream rather than pre-processed pipelines. That bet pays off regardless of whether it's Spud or a subsequent model that lands this capability in production.

Timeline (Polymarket as of April 20, 2026)

Event	Implied probability
Released by April 23	81%
Released by April 30	72%
Released by May 31	93%

Altman said "a few weeks" on March 24. Arithmetically: late April to mid-May. Polymarket pricing matches.

Note: April 16 had a rumored internal release document screenshot that got deleted from X. Whether that was real internal leak or fake is unconfirmed.

Why OpenAI Shut Down Sora Quietly

Compute reallocation. OpenAI pulled GPU capacity from Sora (video generation) and redirected it to Spud. The signal value: OpenAI is treating the Anthropic competition as existential enough to sacrifice a marquee consumer product.

Also worth noting: Spud is reportedly the base model for two upcoming voice agent platforms — not just a chatbot upgrade. OpenAI is betting the 2026-2027 product roadmap on this model.

What to Watch For (and What to Ignore)

Actual signals to track:

SWE-bench Pro number when it drops (deciding factor for enterprise spend)
Context window announcement (agentic task quality)
Pricing (affects adoption curve)
API pass-through latency (native multimodality claim verification)

Noise to ignore:

"Capybara tier" and other extreme rumors
Specific dates floating on X before official announcement
Any claim about AGI or "human-level" anything
The "GPT-5.5 Pro" name until OpenAI actually uses it

Summary

The real story isn't "there's a new model." It's "OpenAI is under actual competitive pressure from Anthropic for the first time, and their internal language is signaling they think this response is significant."

We'll know within 4-6 weeks whether the hype matches reality. Until then, the most actionable thing is to start thinking about your multimodal architectures in a way that assumes unified context rather than pipeline routing.

Primary source: primeaicenter.com/gpt-5-5-review (most thorough English archive)

Secondary: The Information (March 24 pretraining completion), Altman/Brockman X posts, Polymarket, LM Arena observation community.

Disclaimer: AI-assisted analysis of publicly available leaks and statements. Nothing above is financial or procurement advice. Pre-release rumors change frequently.

Vercel's April 2026 Breach: A 3-Step OAuth Supply-Chain Chain Every Dev Should Read

정상록 — Mon, 20 Apr 2026 03:16:13 +0000

On 2026-04-19 (updated 2026-04-20), Vercel published a Security Bulletin confirming unauthorized access to certain internal systems. The technically interesting part isn't "Vercel got hacked." It's how they got hacked: a three-step OAuth chain that started with a third-party AI tool an employee was using.

If you deploy anything on Vercel, you have homework to do this week. Let me break down what happened, what was and wasn't exposed, and the concrete steps that matter.

The attack chain (in one paragraph)

A Vercel employee was using Context.ai, a third-party AI tool. The attacker compromised Context.ai's Google Workspace OAuth application, used it to hijack the employee's Google Workspace account, and from there rode the employee's existing OAuth grant to reach Vercel's internal environment. No MFA bypass. No stolen password. Just a legitimate chain of OAuth consents being inherited by the wrong principal.

[Context.ai] --OAuth--> [Google Workspace] --OAuth--> [Vercel]
     ^                                                   ^
     |                                                   |
 initial breach                                    reached via
   (supply chain)                              inherited OAuth scopes

What got exposed, and what didn't — the `Sensitive` flag saved some secrets

Vercel's post is unusually precise about the blast radius, and this is where the architectural lesson lands.

Non-sensitive environment variables: potentially accessed. Vercel recommends rotating all of them. This is the bucket most teams default into — API keys, DB URLs, JWT secrets, webhook signing keys, LLM credentials.
Sensitive environment variables: no evidence of access. These are stored encrypted and decrypted only at build time, and the value cannot be retrieved in plaintext from the dashboard after creation.

Same variables. Same account. Same dashboard. One checkbox at creation time. That checkbox was the difference between "needs rotation across your entire production stack" and "probably fine."

The IOC you can act on right now

Vercel and downstream security reports published this OAuth App ID:

110671459871-30f1spbu0hptbs60cb4vsmv79i7bbvqj.apps.googleusercontent.com

If you're a Google Workspace admin, go to:

admin.google.com → Security → Access and data control → API controls
→ App access control → Manage Third-Party App Access

Search for that project number (110671459871). If it shows up in your org, you now have a concrete incident to investigate.

Context.ai's OAuth app is being described as part of a larger supply-chain compromise affecting hundreds of orgs — not a Vercel-only issue.

What to do this week — the pragmatic version

Day 0 (today, ~2 hours)

[ ] Search your Google Workspace for the IOC above
[ ] Review Vercel Activity Log (dashboard or vercel ls) for unexpected logins, deployments, env changes
[ ] Upgrade Deployment Protection to at least Standard
[ ] Revoke unused Deployment Protection bypass tokens

Day 1-7 (rotation week)

Rotate everything that was a non-sensitive env var. Prioritize like this:

Priority	Category	Examples
P0 (24h)	Payment / DB	Stripe, Toss, Postgres URL, Redis URL
P0 (24h)	Signing keys	`JWT_SECRET`, `NEXTAUTH_SECRET`, webhook signing
P1 (48h)	LLM APIs	`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`
P2 (7d)	Messaging / storage	SendGrid, Mailgun, S3, Cloudinary

Standard rotation flow:

# 1. Issue a fresh value in the provider's console
# 2. Re-add it as a Sensitive env var
vercel env add STRIPE_SECRET_KEY production --sensitive

# 3. Deploy on the new value
git commit --allow-empty -m "rotate: STRIPE_SECRET_KEY"
git push

# 4. After verification, revoke the old value at the provider

For JWT_SECRET-style keys, remember that rotating them invalidates every existing session. Keep a JWT_SECRET_LEGACY for a 24-72h grace window and accept tokens signed with either, then drop the legacy.

Day 8-30 (structural improvements)

Flip your Google Workspace default OAuth access policy to Restricted; move known-good apps to Trusted, block the rest.
Introduce a secrets manager (1Password Secrets Automation / Doppler / Bitwarden SM) so that Vercel becomes the injection point, not the source of truth.
Add a recurring quarterly calendar event: "OAuth audit — Google, GitHub, Vercel, Slack, Notion."
Install gitleaks as a pre-commit hook to catch accidental secret prints.

The broader takeaway for devs

The attack that got Vercel wasn't novel cryptography, a zero-day, or MFA bypass. It was OAuth consent being treated as low-stakes by the end user.

In 2026, "Sign in with Google" on a new AI tool is effectively deciding: "I'm willing to let this tool's security posture become the lower bound of my entire Google-connected surface area." That includes Vercel, GitHub, Slack, Notion, Supabase, and anything else federated through your Google ID.

If your team doesn't have an AI-tool adoption policy yet, three lines probably cover most of the risk:

Any third-party tool asking for Google Workspace OAuth requires security-owner approval.
Anything beyond read-only scopes needs a written justification.
OAuth grants unused for 30 days are auto-revoked.

That's the price of admission for living on this much managed infrastructure.

Source

Vercel Security Bulletin (official): https://vercel.com/kb/bulletin/vercel-april-2026-security-incident

Stay rotated, devs.

HeyGen HyperFrames: An Open-Source Video Framework Built for AI Agents (Not Humans)

정상록 — Mon, 20 Apr 2026 03:15:53 +0000

TL;DR

HeyGen open-sourced HyperFrames under Apache 2.0 in 2026. Instead of programmable video via React components (like Remotion), you write plain HTML with data-* attributes and GSAP timelines. The design goal is explicit: AI coding agents are the primary users, not humans.

npx skills add heygen-com/hyperframes

This single command installs five slash commands into Claude Code / Cursor / Codex / Gemini CLI and turns your agent into a video editor.

Why Another Video Framework?

The homepage headline is the thesis statement: "Now Claude Code can edit videos."

Content automation pipelines have agent-friendly tools for research, writing, and image generation. Video was the missing piece. The question HyperFrames answers is: "What abstraction level do AI agents handle best?"

The answer, according to HeyGen: HTML. Not JSX, not imperative timeline APIs, just HTML.

The Core Primitive

<div id="root" data-composition-id="root"
     data-start="0" data-width="1920" data-height="1080">
  <video id="clip-1" data-start="0" data-duration="5" data-track-index="0"
         src="intro.mp4" muted playsinline></video>
  <img id="overlay" class="clip" data-start="2" data-duration="3"
       data-track-index="1" src="logo.png" />
  <audio id="bg-music" data-start="0" data-duration="9" data-track-index="2"
         data-volume="0.5" src="music.wav"></audio>
</div>

That is the full mental model. Four clip types:

<video> — must be muted
<img> — static visuals
<audio> — separated from video
<div data-composition-id> — nested compositions

Five required attributes cover timing, layering, and optional volume. A class="clip" tells the framework to honor the data-start/data-duration window.

Determinism Is Non-Negotiable

One of the seven official "must follow" rules caught my eye:

Math.random() is forbidden. If you need randomness, use a seeded PRNG like mulberry32.

That level of commitment to determinism is rare in video tooling. The reasoning is clear: agent-driven pipelines need the same input to produce identical bytes every time, otherwise you cannot put rendering in CI.

Other non-negotiables:

Every timeline must register into window.__timelines
<video> elements must be muted (audio goes into <audio> tags)
GSAP timeline construction must be synchronous (no async/await/fetch)
Timed elements require class="clip"
Never call video.play() or audio.currentTime from scripts — the framework owns media control
Every scene needs an entrance animation
Scenes need transitions between them

Natural Language → Technical Mapping

The prompting guide includes a mapping table that does most of the work:

Natural Language	GSAP Easing
smooth	`power2.out`
snappy	`power4.out`
bouncy	`back.out`
springy	`elastic.out`
dramatic	`expo.out`
dreamy	`sine.inOut`

The same approach for caption tones maps "Hype / Corporate / Tutorial / Storytelling / Social" to specific font weights, entrance animations, and size ranges. The user describes a feeling; the framework resolves to technique.

Two Prompt Modes

Cold Start

10-second product intro, fade-in title, dark background, BGM, corporate mood

Recommended structure:

Duration
Aspect ratio (16:9 / 9:16 / 1:1)
Mood (energetic / calm / premium / playful)
Key elements

Warm Start

This is where HyperFrames shines:

Turn this GitHub repo into a 45-second pitch video
Turn this PDF into a 30-second summary video

The agent handles both research and production in a single prompt. The /website-to-hyperframes slash command is a first-class pipeline for URL → video.

Common Mistakes (The Debugging Cheat Sheet)

From the official Common Mistakes doc, here are the failure modes I would not have guessed:

1. Animating video element dimensions

// ❌ Freezes frame rendering
gsap.to('#video1', { width: 1920, duration: 1 });

// ✅ Animate a wrapper div
gsap.to('.video-wrapper', { width: 1920, duration: 1 });

2. Timeline shorter than video

// Extend timeline with a zero-duration set
tl.set({}, {}, 283);

3. Oversized images

A 7000×5000 PNG causes ~140MB decode per frame. Keep images at 2× canvas size max.

4. Backdrop-filter stacks

16 layers of backdrop-filter: blur() calculated every frame will kill render performance. Cap at 2-3 layers.

Architecture

Monorepo with clean separation:

Package	Responsibility
`hyperframes`	CLI (create, preview, lint, render)
`@hyperframes/core`	Types, parser, linter, runtime, frame adapter
`@hyperframes/engine`	Page → video capture (Puppeteer + FFmpeg)
`@hyperframes/producer`	Full pipeline (capture + encode + audio mix)
`@hyperframes/studio`	Browser-based composition editor
`@hyperframes/player`	Embeddable `<hyperframes-player>` web component
`@hyperframes/shader-transitions`	WebGL shader transitions

The Frame Adapter pattern is the extensibility story. Adapters can bring GSAP, Lottie, CSS animations, or Three.js into the render pipeline. First-mover adapters will probably shape the ecosystem.

TTS Is Built-In

Kokoro TTS runs locally, no API key required:

npx hyperframes tts --text "Hello world" --voice af_heart --output narration.wav

Recommended voices by use case:

Product demos: af_heart, af_nova
Tutorials: am_adam, bf_emma
Marketing: af_sky, am_michael

The Component Registry

Over 50 blocks are registered and installable via CLI:

npx hyperframes add flash-through-white
npx hyperframes add instagram-follow
npx hyperframes add data-chart

Categories include social overlays, shader transitions, data visualizations, and cinematic effects.

Workflow I Would Adopt

npx hyperframes init my-video (installs skill automatically)
Open in Claude Code / Cursor / Codex
/hyperframes with a warm start prompt pointing to source material
npx hyperframes preview for browser live reload
Small, targeted follow-up prompts: "make the title 2x larger", "add a fade-out at the end"
npx hyperframes lint to catch structural issues
npx hyperframes render --preset high --output final.mp4

Anti-Patterns to Avoid

From the prompting guide:

Asking for React/Vue components — adds a translation layer
Requesting 4K/60fps — 1920×1080 30fps is the sweet spot for speed
Skipping the slash command — the agent will fall back to generic HTML video conventions
Giant monolithic prompts — targeted, iterative edits beat one-shot mega-prompts

Requirements

Node.js 22+
FFmpeg

That is the entire system requirement list.

Why This Matters

The design signals a specific bet: the future of content tooling is agent-primary, human-secondary. Most frameworks treat agent support as a retrofit. HyperFrames treats it as the foundational design constraint. Whether that bet pays off or not, the engineering choices (HTML-first, deterministic rendering, slash command integration) are worth studying regardless of which tool you end up using.

Building a Hermes Fleet: Reproducing a Self-Hosted Agent Stack in a Weekend (mem0 + Qdrant + Ollama + Claude Code Stop hook)

정상록 — Fri, 17 Apr 2026 01:28:53 +0000

TL;DR

@Mosescreates posted his Hermes fleet — six agent profiles across two machines, all writing to a shared memory layer made of mem0 + Qdrant + Ollama. I spent the weekend reproducing a stripped-down version with two profiles on a single MacBook. The architecture held.

Load-bearing pieces (don't skip):

Shared Qdrant collection
Local Ollama embeddings
mem0 as memory abstraction
Claude Code Stop hook writing each turn
Native-only OpenRouter provider pinning
Local LLM fallback (Gemma 2 9B 4-bit in my case)

Everything else — second machine, launchd units, backup cron, fleet status CLIs — is nice to have.

Architecture

┌────────────────┐        ┌──────────────────┐
│ Claude Code    │        │ Telegram Agent   │
└────────┬───────┘        └────────┬─────────┘
         │ Stop hook               │ on every reply
         ▼                         ▼
┌────────────────────────────────────────────┐
│             mem0 (Python SDK)              │
│ LLM: OpenRouter (primary) / Ollama fallback│
│ Embedder: Ollama nomic-embed-text (768d)   │
└────────────────────┬───────────────────────┘
                     ▼
         ┌────────────────────────┐
         │ Qdrant (Docker)        │
         │ collection: fleet_memory│
         └────────────────────────┘

Every tool is a reader and a writer of the same store. That's the whole idea.

Bringing up the three services

# Qdrant
docker run -d --name qdrant -p 6333:6333 \
  -v "$HOME/qdrant_data:/qdrant/storage" qdrant/qdrant

# Ollama + embedding model
ollama pull nomic-embed-text
ollama serve &

# mem0
python3.11 -m venv ~/.venv/fleet && source ~/.venv/fleet/bin/activate
pip install mem0ai

Config that actually works

# ~/.mem0/config.yaml
vector_store:
  provider: qdrant
  config:
    host: 127.0.0.1
    port: 6333
    collection_name: fleet_memory
    embedding_model_dims: 768   # <- don't omit this

llm:
  provider: ollama
  config:
    model: llama3.1:8b
    ollama_base_url: http://127.0.0.1:11434

embedder:
  provider: ollama
  config:
    model: nomic-embed-text
    ollama_base_url: http://127.0.0.1:11434

Three things that differ from the original snippet:

All three blocks (vector_store, llm, embedder) are specified. mem0's defaults are OpenAI gpt-4o + text-embedding-3-small. If you only override the embedder, mem0 silently still calls OpenAI for the LLM piece and you get a confusing 401.
embedding_model_dims: 768 is explicit. nomic-embed-text returns 768-dim vectors; mem0's Qdrant default assumes 1536 (OpenAI). Missing this causes silent insert failures — see mem0 issue #3441.
127.0.0.1 over localhost. Happy Eyeballs bit me multiple times on macOS when services resolved to both IPv6 and IPv4.

The Claude Code Stop hook

This is the piece that wires Claude Code into the shared memory. Settings:

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "/Users/you/.venv/fleet/bin/python3 /Users/you/.claude/hooks/mem_broadcast.py"
          }
        ]
      }
    ]
  }
}

Important: use the venv Python explicitly. The hook runs with a non-login shell env, so python3 resolves to system Python, which doesn't have mem0 installed.

The hook script

The original blogpost uses payload.get("transcript", []). The actual Stop hook payload gives you transcript_path — a JSONL file path. You have to open and parse it.

#!/usr/bin/env python3
"""Claude Code Stop hook → mem0 writer with redaction + idempotency."""
import json, os, re, sys
from pathlib import Path
from mem0 import Memory

REDACT_PATTERNS = [
    re.compile(r"sk-[A-Za-z0-9_-]{20,}"),
    re.compile(r"ghp_[A-Za-z0-9]{36,}"),
    re.compile(r"Bearer\s+[A-Za-z0-9._\-]+"),
]

def redact(text: str) -> str:
    for pat in REDACT_PATTERNS:
        text = pat.sub("[REDACTED]", text)
    return text

def main() -> int:
    try:
        payload = json.load(sys.stdin)
    except json.JSONDecodeError:
        return 0

    # Prevent infinite loops
    if payload.get("stop_hook_active"):
        return 0

    transcript_path = payload.get("transcript_path")
    if not transcript_path or not Path(transcript_path).exists():
        return 0

    turns = []
    with open(transcript_path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line: continue
            try:
                turns.append(json.loads(line))
            except json.JSONDecodeError:
                continue

    user_turn = next((t for t in reversed(turns) if t.get("role") == "user"), None)
    assistant_turn = next((t for t in reversed(turns) if t.get("role") == "assistant"), None)
    if not user_turn or not assistant_turn:
        return 0

    session_id = payload.get("session_id", "unknown")
    turn_index = len(turns)
    user_text = redact(str(user_turn.get("content", "")))[:2000]
    assistant_text = redact(str(assistant_turn.get("content", "")))[:2000]

    m = Memory.from_config(os.path.expanduser("~/.mem0/config.yaml"))
    m.add(
        f"User asked: {user_text}\nAssistant answered: {assistant_text}",
        user_id="fleet",
        metadata={
            "source": "claude_code",
            "session_id": session_id,
            "turn_index": turn_index,
            "idempotency_key": f"{session_id}:{turn_index}",
        },
    )
    return 0

if __name__ == "__main__":
    sys.exit(main())

Known Stop hook bug

Claude Code issue #11786 reports a regression in v2.0.42+ where prompt-based Stop hooks can't access transcript content. Reading transcript_path directly (as above) mostly dodges it, but I occasionally saw the last JSONL turn not yet flushed when the hook fired — adding time.sleep(0.2) at the top of main() smoothed it over in practice.

The four-line YAML that matters most

OpenRouter defaults to falling back to cheaper/faster providers. That's fine for a chat UI, catastrophic for an agent that writes to shared memory.

primary:
  provider: openrouter
  model: qwen/qwen-3-72b-instruct
  provider_config:
    only: ["alibaba"]
    allow_fallbacks: false

fallback:
  provider: ollama
  model: gemma2:9b-instruct-q4_0

OpenRouter's provider routing docs officially support provider.only + allow_fallbacks: false. If the pinned provider is down, the call fails loudly instead of silently drifting to another one. Loud failure is what you want when memory consistency is on the line.

Local fallback from day one

30 seconds without network during a conversation — user barely noticed. Memory writes kept going against local Gemma. Recovery was silent. Pull the model once:

ollama pull gemma2:9b-instruct-q4_0

Three lessons the hard way

Happy Eyeballs is real. Pin services to 127.0.0.1, set AddressFamily inet in ~/.ssh/config, use curl -4.
Idempotency keys aren't optional. I skipped them for day one and by Sunday I had duplicate memory entries from mem0 retries after a Qdrant timeout. session_id:turn_index — do it from the start.
Self-hosted embeddings are self-ownership. Cost was a trivial amount of electricity. Privacy is total. If OpenRouter vanishes tomorrow, my memory layer is untouched.

The qualitative part

After roughly 10 minutes of Claude Code work, I asked my Telegram bot "what was I working on?" and it answered coherently from the shared store. I kept catching myself context-switching without re-explaining.

None of this is novel tech. The work is in the wiring — making every tool a reader/writer of the same store, plus enough discipline around idempotency and redaction to trust what's in there.

Closing

Moshe's "nothing lock-in" point hits harder after doing it. When something broke I fixed it. When I wanted a new profile I copied four lines of YAML. No platform was in the loop.

Start: Qdrant + Ollama + mem0. Get Claude Code Stop hook writing. Everything else builds from there.

Credit: Moshe (@Mosescreates) for the original Hermes thread. mem0 / Qdrant / Ollama / Claude Code teams for the underlying pieces. This is just a weekend reproduction.

Full Korean writeup with additional troubleshooting: https://qjc.app/blog/hermes-fleet-self-hosted-agent-stack

OpenAI Agents SDK v0.14 — Sandbox Agents and the Model-Native Harness Go GA

정상록 — Fri, 17 Apr 2026 01:16:51 +0000

On April 15, 2026, OpenAI announced the next evolution of the Agents SDK and shipped openai-agents-python v0.14.0/v0.14.1 with two headline features: Sandbox Agents and a model-native harness. Both are now GA for all API customers.

The one-sentence read: the default shape of "an AI agent" just moved from a chatbot with tool calls to a coworker with a computer.

The three trade-offs OpenAI is trying to escape

OpenAI frames the existing landscape as three approaches, each with a trade-off:

Model-agnostic frameworks (LangChain, LlamaIndex, etc.) — flexible across models, but can't fully exploit frontier model capabilities. There's always a gap between "what the latest model can do" and "what the framework surfaces."
Provider SDKs — closest to the model, but thin on harness observability. Hard to see what a production agent is actually doing.
Managed agent APIs — easy to deploy, but constrain execution location and data access.

The response: split harness and compute. The harness owns the loop, memory, orchestration, observability. The sandbox owns execution, filesystem, network, tool calls. They run in different isolation domains.

The primary reason is security. If model-generated code executes in the same environment as your credentials, you're one prompt injection away from exfiltration. Long-running agents also need to survive environment loss — which a clean split makes tractable.

What landed on the harness side

Feature	What it does
Configurable memory	Reuse lessons across runs, progressive disclosure instead of shoving everything into context
Sandbox-aware orchestration	Route sub-agents into isolated sandboxes
Codex-like filesystem tools	`read`/`write`/`edit` as first-class
MCP support	Native Model Context Protocol (Anthropic's open standard)
Skills	Progressive disclosure of domain capabilities
AGENTS.md	Project-level custom instructions file
Shell tool	1st-class shell command execution
Apply patch tool	1st-class file patching

Two items stand out.

AGENTS.md is essentially CLAUDE.md with a different name. If you've used Claude Code, the concept is identical: a project-root file containing custom instructions for the agent. OpenAI officially adopting this convention is itself a signal — "project-level agent config file" is becoming a cross-provider pattern.

MCP support means OpenAI officially endorsed Anthropic's Model Context Protocol. When both major model providers support MCP, the tool ecosystem becomes portable. This is a bigger deal than the harness features IMO — it's infrastructure-level consolidation.

What landed on the sandbox side

Seven default providers ship out of the box:

Blaxel
Cloudflare
Daytona
E2B
Modal
Runloop
Vercel

Plus BYO sandbox for anyone who wants to run their own isolation layer.

The most interesting piece is the Manifest abstraction — a portable format describing an agent workspace:

Local file mounts
Output directories
Storage integrations (AWS S3, Google Cloud Storage, Azure Blob Storage, Cloudflare R2)
Git repository cloning

If the sandbox container dies, the Manifest lets you reconstruct an identical workspace elsewhere. This is what unlocks the next piece:

Durable execution

Agent state is externalized from the container. Snapshotting and rehydration are built in. If an existing environment fails or expires, the agent resumes from its last checkpoint in a new container.

For long-running tasks — bulk translations, large refactors, overnight research — this is the difference between "I can run this" and "I can run this safely."

Permissions

Per-Manifest-entry file permissions, mapped to Unix filesystem semantics:

dataroom/   → read-only
output/     → writable
config/     → inaccessible

This is not a convenience feature. It's a structural limit on blast radius from prompt injection. Injection isn't prevented, but what an injected instruction can actually do is bounded.

Scaling

One agent run can use one sandbox or many. Sandboxes are called only when needed. Sub-agents route to isolated containers. Container-level parallelism for speed. Cost and performance on the same axis.

Availability and pricing

GA for all OpenAI API customers
Standard API pricing — tokens + tool usage. No new tier.
Python first (v0.14.0+). TypeScript coming later.
Roadmap: Code mode and Subagents expanding to Python and TypeScript.

Ecosystem size at the time of this release: ~14.7M monthly Python downloads, ~1.5M TypeScript downloads, 19,000+ GitHub stars, 250+ contributors.

The Claude Code convergence

If you look at the naming, the parallel with Anthropic's Claude Code is hard to miss:

OpenAI Agents SDK	Anthropic Claude Code
`AGENTS.md`	`CLAUDE.md`
Skills	Skills
Shell tool	Bash tool
Apply patch tool	Edit tool

Both companies converged on the same answer to "what does an AI agent need?" The answer is: shell, filesystem, project-level instructions, tool-use standard (MCP), and a sandbox to do it all safely.

This matters because it redefines the default. "AI agent = chatbot with tools" is dead. "AI agent = semi-autonomous process with a computer" is the new baseline.

Practical angles for small teams

1. Wire Manifest to your data layer directly

Connect S3 or Cloudflare R2 through a Manifest entry. The agent reads source data and writes results itself — no wrapper scripts. This collapses a lot of "data prep → run → save results" plumbing.

2. Safe overnight jobs

With Durable execution, "run 50 translations overnight" is no longer a gamble. Container crashes resume from checkpoints.

3. Security-by-default code agents

Permissions structurally prevent common mistakes like "agent has access to .env and leaks credentials." Solo devs especially benefit — the security layer isn't "remember to configure it," it's "the Manifest says dataroom is read-only."

4. Isolated sub-agent parallelism

Complex tasks split into sub-agents, each in its own sandbox, running in parallel. A pattern that was DIY is now production-ready.

Trade-offs worth watching

TypeScript lag. Python-first is painful for TS/frontend-heavy teams. TypeScript is on the roadmap but timing isn't public.

Provider lock-in risk. Seven sandbox providers is great on paper, but depth of integration with any one will make migration costly. Manifest promises portability — real-world portability always has edges.

Billing predictability. Three cost axes (sandbox compute + tokens + tool usage) make budget modeling harder. Monitor carefully in the early rollout.

Prompt injection is not solved. Harness/compute split limits damage. It doesn't prevent injection. Input validation, least-privilege, and audit logging are still on you.

Bottom line

"AI agent" as an abstraction shifted from "a model that chats and calls tools" to "a semi-autonomous process with sandboxed compute, durable state, and Unix-style permissions." OpenAI formalized the direction Claude Code had been demonstrating, both companies are on MCP, and the practical implications for small teams are real — overnight jobs, direct data-layer access, structural security.

One more stack to learn. Probably worth it.

References

GPT Image 2 Leak: 개발자가 지금 당장 해야 할 5가지

정상록 — Fri, 17 Apr 2026 01:16:46 +0000

TL;DR

2026년 4월 4일 LM Arena에 등장한 3개 익명 모델(maskingtape-alpha / gaffertape-alpha / packingtape-alpha)이 GPT Image 2로 추정됩니다. near-perfect 텍스트 렌더링과 네이티브 4K 해상도가 핵심입니다. DALL-E는 5월 12일 종료 예정이라, 지금이 API 마이그레이션을 준비할 마지막 타이밍입니다.

뭐가 바뀌나

GPT Image 2의 핵심 업그레이드 5가지를 개발자 관점에서 정리했어요.

near-perfect 텍스트 렌더링 → UI 목업의 수정 왕복이 사라집니다
네이티브 4K → 2048x2048 기본, 4K 업스케일 지원
포토리얼리즘 → AI 판별기가 실패한 비치 셀카 리크
월드 지식 강화 → 실제 브랜드/장소 정확한 렌더링
독립 아키텍처 → GPT-4o 기반 아닌 이미지 전용 모델

코드로 확인하는 현재 상태

기존 OpenAI 이미지 API는 이렇게 생겼습니다.

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.images.generate({
  model: "gpt-image-1",
  prompt: "A modern dashboard UI with pricing cards",
  size: "1536x1024",
  quality: "high",
});

console.log(response.data[0].b64_json);

GPT Image 2가 정식 출시되면 모델명과 size가 바뀔 가능성이 높습니다. 예상 형태는 이렇습니다.

// 예상 (공식 스펙 미공개)
const response = await client.images.generate({
  model: "gpt-image-2",           // maskingtape/gaffertape/packingtape 중 하나가 stable이 될 가능성
  prompt: "A modern dashboard UI with pricing cards, 'Upgrade now' button",
  size: "2048x2048",              // 네이티브 4K
  quality: "standard" | "hd",      // hd가 4K 업스케일
});

마이그레이션 준비 코드

DALL-E 의존 코드를 GPT Image 계열로 전환하는 어댑터 패턴을 만들어두면 전환이 쉬워집니다.

// image-provider.js
const PROVIDERS = {
  "dall-e-3": {
    model: "dall-e-3",
    maxSize: "1792x1024",
    deprecated: "2026-05-12",
  },
  "gpt-image-1": {
    model: "gpt-image-1",
    maxSize: "1536x1024",
    deprecated: null,
  },
  "gpt-image-2": {
    model: "gpt-image-2",
    maxSize: "2048x2048",
    deprecated: null,
    native4k: true,
  },
};

export async function generateImage(prompt, options = {}) {
  const provider = PROVIDERS[options.model || "gpt-image-1"];

  if (provider.deprecated && new Date(provider.deprecated) < new Date()) {
    throw new Error(`${provider.model} deprecated on ${provider.deprecated}`);
  }

  const response = await client.images.generate({
    model: provider.model,
    prompt,
    size: options.size || provider.maxSize,
    quality: options.quality || "standard",
  });

  return response.data[0];
}

프롬프트 전략 변화

기존 GPT Image 1에서는 이미지 내 텍스트를 생성할 때 짧게 끊어야 했습니다.

// BAD: 1.5 버전에서 자주 깨짐
const prompt = "A billboard with the long slogan: 'The future of AI is not predicting but creating, one pixel at a time'";

// GOOD: 1.5 버전에서도 안정적
const prompt = "A billboard with the text 'Future is Now' in bold white";

GPT Image 2에서는 장문 텍스트도 near-perfect로 렌더링된다고 하니, 프롬프트 길이 제약이 완화될 것으로 예상됩니다.

// GPT Image 2 예상: 장문 텍스트도 안정적
const prompt = "A startup pitch slide titled 'Q2 Growth Metrics'. Three data cards: 'Users: +42%', 'Revenue: $1.2M MRR', 'Churn: 2.1%'. Clean dark theme, white text, purple accents.";

지금 해야 할 체크리스트

출시 전까지 개발자가 준비해야 할 것들입니다.

[ ] 기존 DALL-E 호출 지점 전수 조사 (5/12 이후 깨집니다)
[ ] 4K 출력을 고려한 CDN 및 스토리지 용량 재점검
[ ] 프롬프트 저장소에 길이별 테스트 케이스 준비
[ ] API 요금 변화 대응을 위한 cost tracking 코드 추가
[ ] 이미지 provider 어댑터 레이어 도입 (위 코드 참고)

한 가지 주의사항

"GPT Image 2"라는 이름 자체는 아직 OpenAI 공식 명칭이 아닙니다. 커뮤니티 추정입니다. 다만 LM Arena 등장과 A/B 트리거 보고는 팩트라 실체가 있다는 것은 확실합니다.

공식 발표가 나오면 모델명과 size 파라미터를 실제 값으로 교체하면 됩니다. 그 전까지 마이그레이션 구조만 미리 준비해두세요.

참고 자료

Claude Opus 4.7 is out — what actually changed for developers

정상록 — Fri, 17 Apr 2026 01:16:11 +0000

TL;DR

Anthropic dropped Claude Opus 4.7 yesterday (April 16, 2026). Price is identical to 4.6 ($5/$25 per M tokens) but SWE-bench Pro rose from 53.4% → 64.3% — actually passing GPT-5.4 (57.7%). The practical changes that matter: Claude Code now defaults to a new xhigh effort tier automatically, a /ultrareview slash command runs dedicated code review sessions, and the new tokenizer inflates the same input by 1.0–1.35x tokens. You probably need to bump max_tokens to 64k+ and retest prompts you wrote for 4.6.

What Anthropic actually shipped

Model ID:      claude-opus-4-7
Release:       2026-04-16 (GA)
Price:         $5/M input, $25/M output (unchanged from 4.6)
Availability:  Claude API · Amazon Bedrock · GCP Vertex AI · Microsoft Foundry

If you're used to thinking of Opus releases as marginal, 4.7 is not that kind of release.

Benchmark deltas that aren't just noise

                        Opus 4.6    Opus 4.7    Delta
SWE-bench Verified        —          87.6%       —
SWE-bench Pro            53.4%       64.3%      +10.9pp
CursorBench              58%         70%        +12pp
XBOW visual accuracy     54.5%       98.5%      +44pp
Databricks OfficeQA Pro   —          err -21%    —
Rakuten SWE-Bench         —           3x tasks    —

The one I'd focus on is XBOW. Vision accuracy going from 54.5% to 98.5% isn't benchmark farming — it's the difference between "computer-use agents are a demo" and "I can actually ship one."

The xhigh effort tier (and why Claude Code just got better for free)

Effort levels used to be low | medium | high | max. 4.7 adds xhigh between high and max.

# Anthropic SDK
from anthropic import Anthropic

client = Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=64000,  # bump from 32k — xhigh produces longer reasoning
    thinking={"type": "enabled", "budget_tokens": 30000},
    effort="xhigh",  # new tier
    messages=[{"role": "user", "content": "..."}]
)

The invisible change: Claude Code defaulted every plan to xhigh automatically. You don't set anything. Quality went up, nothing in your CLI config changes.

/ultrareview — a review session that actually pushes back

/ultrareview

This runs a dedicated review pass that flags bugs and design issues. Pro/Max users get 3 free sessions per month.

Vercel's team noted after testing: "new behavior of starting from proofs for systems code." In practice it's more willing to say "this invariant isn't being preserved here" than prior Claude versions, which tended toward agreement.

Migration: things that will bite you

1. Token usage goes up — sometimes a lot

New tokenizer. Same input now uses 1.0x–1.35x tokens depending on content type. Code-heavy inputs trend toward the high end.

# Before (4.6)
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=32000,
    messages=messages
)

# After (4.7) — needs headroom
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=64000,  # xhigh reasoning expands late-turn output
    messages=messages
)

Anthropic claims efficiency improved at all effort levels (shorter output for same quality). My anecdotal tests back this up for coding tasks but it varies. Don't assume, measure.

2. Instruction-following is now strict

This is the hidden gotcha. 4.7 executes prompts literally. Implicit assumptions you leaned on with 4.6 — "obviously Claude will skip step X if condition Y" — no longer hold.

# A prompt that used to "just work"
"Refactor this function and add tests if needed."

# 4.7 behavior: always adds tests, even when not needed
# 4.6 behavior: would judge whether tests were warranted

Anthropic's own migration guide recommends re-tuning prompts and agentic harnesses. Plan the time.

3. Task Budget (public beta) — let the model see its own budget

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=64000,
    task_budget={"remaining_tokens": 50000},  # beta
    messages=messages
)

You tell Claude how many tokens are left. It prioritizes and gracefully winds down as the budget drops. Actually useful for long agentic loops that used to die mid-step.

Safety direction: intentionally narrower

Worth noting because it's unusual: 4.7 is the first Anthropic model where cyber capabilities were deliberately scaled back. A new Cyber Verification Program exists for legitimate security researchers (vuln research, pentesting, red teaming) to regain expanded access through a vetting process.

If you're in security and hit capability walls you didn't see in 4.6, that's why.

What partners are saying (filter for patterns, not hype)

The repeated keywords across partner quotes are what matter:

"stays coherent for hours" (Cognition/Devin)
"doesn't give up on hard problems" (Cognition)
"passes implicit-requirement tests" (Notion Agent)
"starts from proofs for systems code" (Vercel)
"loop resistance, consistency, graceful error recovery" (Genspark)

Translation: the model doesn't just benchmark better, it behaves differently in long-running agentic setups.

Tonight's checklist

pip install -U anthropic (or update your Claude Code client)
Run one existing prompt against claude-opus-4-7 and diff the output
Bump max_tokens in every API call to 64k
Try /ultrareview on a PR you're not sure about
Before rolling 4.7 into a production agent: budget 1-2 hours for harness re-tuning

FAQ

Is there a free tier?

No. API pricing is identical to 4.6 ($5/M input, $25/M output). Claude Pro and Max plans get Claude Code access including the new xhigh default.

Do I need to change my model ID?

Yes. claude-opus-4-7. The old claude-opus-4-6 ID still works during the deprecation window.

Is Mythos Preview the same thing?

No. Mythos Preview is an unreleased Anthropic model available only via limited preview. Opus 4.7 is the strongest generally available model.

Will 4.7 break my existing Claude Code setup?

Almost certainly not — Claude Code handles the transition. What may feel different is faster quality improvement because xhigh is on by default. Your prompts may still need re-tuning.

Forem: 정상록

OmniVoice: Open-Source TTS with 600+ Languages and Zero-Shot Voice Cloning

OmniVoice: Open-Source TTS with 600+ Languages and Zero-Shot Voice Cloning

The Numbers That Matter

Three Modes in One Model

1. Voice Cloning

2. Voice Design

3. Auto Voice

Installation

Fast Path: Web Demo

CLI Tools

Expression Control with Inline Tokens

Pronunciation Override

English (CMU notation)

Chinese (Pinyin with tone numbers)

Architecture Notes

Production Tips from Issue #44

Who This Is For

What's Next

Resources

chrome-devtools-mcp: Google's Official MCP Server That Lets AI Agents Drive Chrome DevTools

chrome-devtools-mcp: Google's Official MCP Server That Lets AI Agents Drive Chrome DevTools

TL;DR

What it actually does

Installation

Method 1: MCP server only

Method 2: Plugin (MCP + Skills)

Requirements

The feature that changed my workflow: --autoConnect

chrome-devtools-mcp vs Playwright MCP

Real-world workflow examples

Weekly performance audit

Pre-deploy smoke test

Production incident triage

Useful flags

Security caveats (do not skip)

FAQ

Verdict

References

Claude Cowork Goes GA — Why Live Artifacts Change How We Work With AI

What Cowork Actually Is

Why Live Artifacts Matter

1. You see state changes as they happen

2. Artifacts run in isolated VMs

3. MCP integrations pipe real data in

The Timeline That Got Us Here

What the April 9 GA Actually Added

Solo Operator Playbook

Pattern 1: Projects per Role

Pattern 2: Live Artifacts for Numerical Decisions

Pattern 3: Meeting-to-Action Pipeline

Honest Limitations

Network restrictions

Memory scope

Desktop only

Cost structure

Getting Started in 5 Minutes

Bottom Line

Claude Design Launch — How Anthropic Made Figma's Stock Drop 7% in One Day

Claude Design Launch — How Anthropic Made Figma's Stock Drop 7% in One Day

TL;DR for Engineers

The Five Features That Matter

1. Prompt → Visual in ~30 seconds

2. Interactive inline edits

3. Team design system ingestion

4. Claude Code handoff

5. Multi-format export

How to Actually Use It — 6 Steps

Prompt pattern that actually works

Why Figma Stock Dropped

The Honest Part — What r/ClaudeAI Complains About

Workarounds I've Found

Competitive Landscape for Devs

My Take

Resources

Claude Code Advisor: Opus Steering Sonnet Inside a Single API Call

Claude Code Advisor: Opus Steering Sonnet Inside a Single API Call

The Benchmark Story

How It Works

When to Call the Advisor

The feature that changed my workflow: `--autoConnect`

What got exposed, and what didn't — the `Sensitive` flag saved some secrets