DEV Community: Evan-dong

# I Went Through 60 Curated Claude Fable 5 Cases So You Don't Have To — Here's What's Actually Useful

Evan-dong — Thu, 11 Jun 2026 10:11:59 +0000

Every model launch buries you in the same noise: Twitter threads saying "this just works," demo clips with no numbers, benchmark pages that disagree with each other. When you actually want to know will this work for my task, and what will it cost, the signal is scattered across a dozen places.

So I went through awesome-claude-fable-5, a curated list of 60 real-world Claude Fable 5 cases, each logged with its source, evidence type, and date. The repo's stated principle is the reason I bothered: concrete evidence over hype — reproducible prompts, demos, cost data, and caveats, not vibes.

Here's how it's organized and the cases worth your time.

How each case is logged

Every entry answers four questions, which is what makes the list scannable:

Input — prompt, screenshot, codebase, logs
Process — which tool/model, how it was run
Output — result plus time, tokens, cost
Evidence type — Demo / Tutorial / Evaluation / Integration

60 cases across 8 categories: coding, agents & long-running automation, games & interactive demos, visual/design/video/3D, documents & research, tutorials & prompt resources, platform/API integration, and evaluations/comparisons/limits.

Coding: screenshot → working clone

One case pastes a single GitHub UI screenshot and asks for a working clone. Reported: ~10 minutes of coding, ~$4.07. The category also covers a single-file macOS-style web OS and large-PR reviews. Good for gauging how far screenshot-to-frontend actually goes today.

Agents: real incident diagnosis, not toy demos

The case that stuck with me: a self-hosted infra outage diagnosed by reading pod logs, querying Cloud SQL error logs, and comparing image digests — landing on "Kubernetes ran a 3-month-old cached image against a freshly migrated DB," then opening a fix PR in minutes, no web search.

Another rebuilt a stalled site (GPT-5.5 and Claude 4.8 had plateaued at 85–90% even with a Figma reference) by going to the original Webflow source, pulling assets, and reproducing it nearly in one pass.

The pattern worth stealing: "Relay"

This recurs across the repo and it's the most practical takeaway: plan, architect, and review with the expensive model; route high-volume implementation to cheaper ones (4.8, GPT-5.5, Sonnet 4.6). One case phrases it as "think with Fable 5, build with a cheaper model, review with Fable 5." If you care about cost, this one idea pays for the read.

The limits are documented too (this is the good part)

The repo doesn't hide the failures. One comparison ran the same Physarum simulation on both stacks: GPT-5.5 (Codex) finished in 17 min for ~$6; Fable 5 (Cursor) took 40+ min and $360.55. A tens-of-times cost gap on the same task. There's also a safety-routing mechanism — cyber/bio-chem/distillation queries get routed to Opus 4.8 instead of refused, triggering in <5% of sessions on average (measured 2–9% depending on the benchmark).

Reproducible prompts you can copy

The tutorials section ships full prompts, not summaries: a DEVICE HARDENING security-pass prompt (model self-check → inventory → 11-category walkthrough → report), a /goal site design-audit prompt with P0–P3 tagging and output paths, and a 4-phase Repo Audit prompt. Worth reading just for prompt-engineering structure.

Trying it yourself

Each case is meant to be reproducible, and the repo includes a curl example against an EvoLink-compatible Messages API:

curl --request POST \
  --url https://direct.evolink.ai/v1/messages \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{ "model": "claude-fable-5", "max_tokens": 1024, "messages": [{ "role": "user", "content": "Hello, world" }] }'

Reported official benchmarks listed with sources: SWE-Bench Pro 80.3%, Terminal-Bench 2.1 88.0%, OSWorld-Verified 85.0%.

One honest caveat

Almost every number here is creator-reported — pulled from X posts and public demos, curated with its source rather than independently re-verified. The Physarum gap shows how much tool/setup/timing swings results. Treat the figures as a reference range, not gospel.

You can browse the full 60-case list on GitHub (Korean README included).

And if you want to reproduce a case and test the model directly, you can try claude-fable-5 on EvoLink.

10 Claude Code Settings I Wish I'd Configured on Day One

Evan-dong — Wed, 10 Jun 2026 09:44:31 +0000

I used Claude Code daily for six months before I admitted the obvious: the defaults were costing me 10–15 hours a month. Not because the tool is bad — because I never configured it. The agent would wander off, forget decisions mid-session, or confidently rewrite code I hadn't asked it to touch, and I'd clean up after it.

This isn't a "what is Claude Code" tutorial. It's the settings I landed on if you already use it and want more out of it. Each section ends with copy-paste config.

1. Cap CLAUDE.md at 8,000 characters

My biggest early mistake was dumping everything into CLAUDE.md. By March it was 40,000 characters. I assumed more context meant better output. Wrong — and the reason is structural: transformers are bad at retaining info in the middle of long documents. Past a certain size the agent stops seeing middle-of-file rules. I asked it to reproduce a rule from line 300 of its own CLAUDE.md; it couldn't.

Hard cap the main file at 8,000 characters. Everything else goes into files loaded on demand:

.claude/
├── CLAUDE.md              # always-on context, ≤ 8,000 chars
├── skills/
│   ├── nestjs.md          # NestJS session rules
│   ├── migration.md       # TS migration rules
│   └── testing.md         # test strategy
└── specs/
    ├── domain-model.md
    ├── api-contracts.md
    └── infra.md

CLAUDE.md holds only what every session needs: stack, hard prohibitions, links to specs and skills. After the refactor: 6,000 chars, more accurate answers, ~35% lower session-init token cost.

2. settings.json — the permissions that change your rhythm

Most devs never open settings.json. Add this and read/test commands stop interrupting you:

{
  "permissions": {
    "allow": [
      "Bash(git log:*)",
      "Bash(git diff:*)",
      "Bash(git status:*)",
      "Bash(npm test:*)",
      "Bash(npm run lint:*)",
      "Bash(npm run typecheck:*)"
    ],
    "deny": [
      "Bash(git push:*)",
      "Bash(git reset --hard:*)",
      "Bash(rm -rf:*)"
    ]
  }
}

Interruptions per session went from 15–20 to 2–3. deny outranks allow, so dangerous commands stay blocked. Commit .claude/settings.json and the whole team gets the same guardrails.

3. acceptEdits — enable it selectively, not globally

acceptEdits removes per-edit confirmations. It helps for a specific class of work:

Enable for: type migrations (JS→TS, fixing any), mechanical fixes (renames, import swaps, formatting), test generation against existing logic, docs/comments.

Don't enable for: new features, architectural refactors, auth/payment/data-layer changes, or any task where you can't state the "done" criteria in 10 seconds.

Real example: I enabled it for "clean up unused imports." The agent tidied the imports, then decided to rewrite a few services while it was in there. Valid, worse than our patterns, 30 unplanned minutes of review. My rule: acceptEdits only when automated tests can catch the mistake.

4. Hooks as guardrails — the 3 that earned their keep

Hooks are the most underrated feature. Shell scripts that run before/after tool calls, receiving JSON context on stdin.

Stop hook — log every session:

#!/bin/bash
# ~/.claude/hooks/stop.sh
TASK=$(cat /tmp/claude_current_task 2>/dev/null || echo "no task recorded")
echo "$(date '+%Y-%m-%d %H:%M') | $TASK" >> ~/.claude/session_history.log

A month of this gave me an honest report: ~2h15m/day with the agent, 4–5 sessions. I thought I used it "occasionally." The data disagreed.

PreToolUse hook — block dangerous commands. Return exit 2 to block and pass stderr back to the agent:

#!/bin/bash
# ~/.claude/hooks/pre_tool.sh
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
DANGEROUS="(rm -rf|DROP TABLE|truncate|DELETE FROM.*WHERE 1=1|git reset --hard|kubectl delete)"
if echo "$COMMAND" | grep -qiE "$DANGEROUS"; then
  echo "BLOCKED: potentially dangerous command: $COMMAND" >&2
  exit 2
fi
exit 0

Fired 7 times in 3 months. 5 were reasonable (I ran them manually after review); 2 I was glad it caught.

Notification hook — ping when done:

#!/bin/bash
osascript -e 'display notification "Claude Code finished the task" with title "Claude Code"'
# Linux: notify-send "Claude Code" "Task done"

Wiring them up:

{
  "hooks": {
    "Stop": [{ "matcher": "", "hooks": [{ "type": "command", "command": "~/.claude/hooks/stop.sh" }] }],
    "PreToolUse": [{ "matcher": "Bash", "hooks": [{ "type": "command", "command": "~/.claude/hooks/pre_tool.sh" }] }]
  }
}

5. Multi-model council for architecture decisions

For hard-to-roll-back decisions (module layout, data schema, service contracts), I run the same task across models in parallel:

Opus:   "Design [X]. Priority: reliability and explicit contracts"
Sonnet: "Design [X]. Priority: development speed"
Haiku:  "Design [X]. Minimal complexity, minimal abstraction"

Then a fourth Opus session synthesizes the best of the three against our context. ~20–25 minutes. On my last big refactor it replaced a week of team debate and landed cleaner than a 2–3 person discussion would have.

6. "Effort levels" — match depth to the task

I formalized this as a custom skill with four levels. (/effort is my skill, not built in; the built-in way to deepen reasoning is keywords like think / ultrathink.)

/effort low     fast draft, no plan, just code        → small utilities, throwaway
/effort medium  short plan, then implement            → standard features, fixes
/effort high    detailed plan, then implement         → new components, public API changes
/effort max     analyze → plan → approval → implement → report; stop for OK at each step
                                                       → core changes, auth, schema migrations

Zero full rollbacks on /effort max in six months. Bonus: if /effort max feels like overkill for a task, the task is easier than you thought. The reverse holds too.

7. Spot context rot early and restart

Long sessions degrade. Three tells:

The agent re-proposes something you already rejected this session
It suggests changing code it just wrote
It asks you to "clarify the task" you gave 10 messages ago

Don't push through. Restart with a short handoff:

# Context to continue
**Task:** [one sentence]
**Done:** [file/function]: [what], ...
**Ruled out (discussed):** [option]: [why], ...
**Next step:** [one concrete item]

3–5 minutes to fill out, 5–10x faster than dragging a rotted session. My personal trigger: 3 messages with no forward progress → restart, no debate.

8. The two-correction rule

If you correct the agent twice on the same point in one session, stop. That's a signal the task framing or context is wrong, not that the agent is stubborn. Rebuild the task three ways:

Split smaller. Two failures on X may mean X is too big. Solve X1 then X2.
Give a concrete example of the desired output instead of "do it right."
Write the skeleton (structure, signatures) and let the agent fill it in. "Here's the service interface, implement it" beats "write a service for X."

Estimated 15–20 hours saved over six months.

9. Split settings by environment

Settings merge hierarchically: team .claude/settings.json, personal .claude/settings.local.json (gitignored), user-global ~/.claude/settings.json.

Team (strict, committed):

{ "permissions": { "deny": ["Bash(kubectl delete:*)", "Bash(terraform destroy:*)", "Bash(rm -rf:*)"] } }

Personal (local, gitignored):

{ "permissions": { "allow": ["Bash(docker compose up --build:*)", "Bash(npm run db:reset:*)"] } }

You move fast locally without losing the shared guardrails — deny outranks allow, so a local allow can't override a team deny. You can also switch permission modes at launch (--permission-mode plan) for investigation-only sessions.

10. Skills: lazy-load project-specific context

Skills are markdown files in .claude/skills/, loaded on demand. The point: don't keep project-specific context in the agent's memory full-time.

.claude/skills/
├── nestjs-conventions.md
├── clean-arch.md
├── typescript-strict.md
├── git-workflow.md
├── testing-strategy.md
└── code-review-checklist.md

Each maps to a task type — writing a NestJS module → nestjs-conventions, refactoring → clean-arch, reviewing → code-review-checklist. After moving to skills: main CLAUDE.md from 40K to 6K chars, 30–40% lower token use in standard sessions, and the agent stopped mixing rules from different domains.

Where this leads

Once you're running multiple models in parallel (#5), the next question isn't prompt quality — it's routing and cost: who uses which model, and what does each workflow cost? That part lives outside Claude Code. Routing the CLI through a gateway gives you per-workflow, per-model cost visibility across providers; the EvoLink Claude Code CLI guide documents that setup if your team's at that stage.

Takeaway

Claude Code isn't plug-and-play — it's a platform you configure. Defaults run at "fine"; the right settings move it to "genuinely fast." By my estimate these paid back 50–60 hours in the first six months. If you've got settings that didn't make my list — especially hooks — drop them in the comments.

Claude Code docs

tags: claude-code, ai, developer-tools, productivity

A Seedance 2.0 Prompt Template for More Controllable AI Video

Evan-dong — Fri, 05 Jun 2026 09:03:52 +0000

I have been collecting working Seedance 2.0 prompts, and one thing keeps showing up:

Good video prompts are not just descriptive. They are structured.

We published the collection here:

https://github.com/EvoLinkAI/awesome-seedance-2.0-prompts

It has 160+ curated Seedance 2.0 prompt cases across product ads, POV shots, cinematic scenes, camera motion, first-frame control, fantasy, action, and reference-driven workflows.

This is the template I would use when writing new prompts.

The template

Intent:
What should this clip communicate?

Scene:
Where does it happen? What should the environment feel like?

Subject:
Who or what is the main focus? What must stay consistent?

Camera:
Where does the camera start? How does it move? Are cuts allowed?

Timeline:
0-2s: ...
2-5s: ...
5-8s: ...

Style:
Lighting, color, lens feel, genre, texture.

Constraints:
What should not happen?

The most useful blocks are usually Camera, Timeline, and Constraints.

Why this helps

A prompt like this:

A man running through a city at night, cinematic, dramatic, realistic, fast camera.

can work, but it leaves too much open.

The model has to guess:

whether the camera follows from behind or from the side;
whether the shot cuts;
whether the man should stay visually consistent;
how fast the camera should move;
what should happen at the end.

For video, those guesses matter.

Example: action shot

Intent:
Create an 8-second continuous chase shot.

Scene:
Crowded old market street at dusk, warm lamps, narrow alleys, moving pedestrians.

Subject:
One young protagonist sprinting through the crowd. Keep the same outfit and silhouette throughout.

Camera:
Handheld tracking shot from behind, then side tracking, then a forward push as the character looks back.

Timeline:
0-2s: camera follows closely behind.
2-5s: side tracking as the character dodges pedestrians.
5-8s: push forward as the character glances back.

Style:
Cinematic thriller energy, readable motion, natural crowd ambience.

Constraints:
No cuts, no face morphing, no outfit change, no chaotic motion blur.

The trick is to stop writing one big paragraph and start writing a small shot plan.

Example: product ad

Intent:
Create a premium product hero shot.

Scene:
Dark reflective studio surface, subtle haze, controlled highlights.

Subject:
One luxury watch. Preserve the watch face, metal edges, proportions, and logo placement.

Camera:
Start with an extreme close-up on the dial, then slowly orbit right.

Timeline:
0-2s: close-up on dial and polished metal.
2-5s: slow orbit reveals the silhouette.
5-8s: centered hero frame.

Style:
Premium commercial lighting, crisp reflections, cinematic contrast.

Constraints:
No logo distortion, no extra text, no shape change, no abrupt cuts.

For products, "what not to change" is often more important than "make it beautiful."

How I use the repo

I would use the GitHub repo as a reference library:

Pick a category close to your target output.
Study the structure, not just the words.
Start with short clips.
Keep camera movement simple.
Save prompt formats that produce stable results.
Turn the best ones into templates.

The full open-source collection is here:

https://github.com/EvoLinkAI/awesome-seedance-2.0-prompts

The visual prompt page is here:

Seedance 2.0 prompt examples

If you have a prompt format that works well for Seedance 2.0, especially for product videos or character consistency, PRs are welcome.

Claude Code Dynamic Workflows: What I Learned From a 111-Agent Research Run

Evan-dong — Thu, 04 Jun 2026 11:08:30 +0000

I tried Claude Code's new dynamic workflows with Opus 4.8 on a real research task.

The short version: the agent count was interesting, but the failure handling was more useful.

What I ran

I used the built-in workflow:

/deep-research <research question>

The question was broad enough to need multiple angles: understand an AI project related to medical imaging, compare possible use cases, look at competitors, and identify product weak spots.

After launching the workflow, I inspected it with:

/workflows

That view shows the phase structure, agent counts, token totals, and runtime.

The phase breakdown

My run split into five phases:

Phase	Agents	Purpose
Scope	1	Define the research frame
Search	6	Search from several angles
Fetch	28	Retrieve and read sources
Verify	75	Check key claims
Synthesize	1	Produce the final report

Total: 111 agents.

Important caveat: this does not mean 111 agents ran at the same time. The point is that the workflow had a script-like structure that coordinated many subagents across phases.

The useful failure

The Verify phase extracted 25 claims and tried to check each claim with three independent agents.

Then the run partially broke.

In my case, 17 of the 25 claims ended up with a killed status. The issue looked like a StructuredOutput failure.

That sounds bad, but the workflow's interpretation was the useful part.

It separated:

confirmed;
contradicted;
not verified.

Only 2 of the 17 killed claims were actually contradicted. The other 15 were incomplete checks, not false claims.

That distinction matters.

killed should not automatically mean "wrong." It means the check did not finish. If your agent turns that into a confident conclusion, the report becomes dangerous.

Why workflows feel different from long chats

In a normal long chat, intermediate state gets compressed into the final answer. That is convenient, but it can hide weak spots.

With a workflow, the plan moves into a script. The runtime can hold phase state, branch logic, repeated checks, and failed agents without forcing everything into the chat context.

That makes it better for tasks where process quality matters:

codebase audits;
large migrations;
cross-checked research;
repeated claim verification;
multi-angle planning.

It is not a good fit for every task. For small edits or quick debugging, it is overkill.

My checklist

Before running a dynamic workflow, I would do this:

Narrow the question.
Run a small version first.
Open /workflows, not just the final report.
Inspect failed, killed, contradicted, and not-verified states separately.
Do not treat killed as a refutation.
Save the workflow only after it proves useful.
Watch token usage.

Takeaway

Dynamic workflows are not just "more subagents."

They are a way to turn a long task into an inspectable process.

My run partially failed, but that failure was visible. For automated research and coding-agent work, visible failure is much better than a clean answer that hides uncertainty.

If you are testing Opus 4.8 for Claude Code, coding agents, or long-running workflows, I keep the model notes and API routing details here: Claude Opus 4.8 API for Coding Agents.

I Generated a Full Brand Mockup Set from a Logo in 10 Minutes — Here's the Workflow

Evan-dong — Sat, 23 May 2026 12:02:18 +0000

I Generated a Full Brand Mockup Set from a Logo in 10 Minutes — Here's the Workflow

Every time I finish a logo, the same problem comes back: how do I show what this brand actually looks like in the real world? Clients don't react to a mark on a white background. They want to see signage, cards, packaging, booths, and product surfaces.

That part usually takes half a day of mockup sourcing and layout work. I wanted to see if Image 2 could compress that.

Who this is for: designers, brand consultants, or developers building brand-adjacent tools who want a faster mockup workflow.

The framework

I split the output into six categories before generating anything:

Logo material and finish studies
Single branded item mockups
Combined brand material sets
Spatial and environmental scenes
Human or usage scenarios
Social media visuals

The planning prompt

Once you have the categories, use this prompt to generate a plan:

I already have a logo. The industry is [industry]. The brand personality is [keywords]. Based on the uploaded logo, help me plan a complete logo mockup generation set. Include: 1) logo material variations, 2) single brand applications, 3) combined brand materials, 4) spatial scenes, 5) human or usage scenarios, and 6) social media visuals. For each category, provide the recommended visual direction, aspect ratio, and prompts that can be used directly in Image 2. Keep the logo recognizable, choose materials appropriate to the industry and brand personality, and make the outputs suitable for a brand proposal.

Test 1: Evolink (tech/API brand)

Brand inputs: professional, stable, developer-friendly, enterprise-ready, connected.

Image 2 generated logo finishes, interface materials, developer badges, documentation covers, and booth-style spatial visuals.

After one round, Evolink stopped looking like just a geometric mark. It started to feel like a real company with booths, dashboards, documentation, and team assets.

Test 2: MoriJoy (nature park brand)

To see if this holds outside tech, I tried MoriJoy — a parent-child nature park. Logo: smiling treehouse + sapling. Palette: wood tones, cream, light green. Personality: soft, warm, healing, natural, playful, family-oriented.

The mockup directions shifted completely: entrance signage, membership cards, staff name tags, children's drinkware, sticker sets, tote bags, family activity spaces.

Same workflow, completely different visual language. The system adapts the brand world around the logo.

What I learned

The six-part framework prevents random outputs and keeps the set coherent.
Defining brand personality keywords before generating makes a big difference.
Not every output is perfect — you still need design judgment to pick the best directions.
This works best for early-stage proposals and direction-setting, not final production.
The workflow compresses what normally takes half a day into about 10 minutes.

Try it

If you're building brand proposals or need to show a logo in context quickly, this workflow is worth testing.

Upload your logo and generate a full brand mockup set with Image 2: https://evolink.ai/gpt-image-2

Gemini 3.5 Flash Just Shipped — Here's When to Use It (and When Not To)

Evan-dong — Wed, 20 May 2026 10:33:55 +0000

Google launched Gemini 3.5 Flash at I/O 2026 today. The "budget" model now beats Gemini 3.1 Pro on agent and coding benchmarks. Here is what you actually need to know to decide whether to switch.

Quick specs

Model ID: gemini-3.5-flash
Context: 1M input / 65K output
Input: text, image, audio, video, PDF
Pricing: $1.50/M input, $9.00/M output, $0.15/M cached input
Knowledge cutoff: January 2026
Dynamic Thinking: on by default (medium), low mode available

Where Flash wins

Benchmark	Flash	3.1 Pro	Gap
Terminal-Bench 2.1 (coding)	76.2%	70.3%	+5.9
MCP Atlas (tool calling)	83.6%	78.2%	+5.4
Finance Agent v2	57.9%	43.0%	+14.9
GDPval-AA (decision-making)	1,656 Elo	1,314 Elo	+342
CharXiv Reasoning	84.2%	—	—

Where Flash does NOT win

Humanity's Last Exam: 3.1 Pro leads (44.4% vs 40.2%)
ARC-AGI-2: 3.1 Pro leads (77.1% vs 72.1%)
SWE-Bench Pro: Claude Opus 4.7 still leads
Computer Use: GPT-5.5 is the only model with production screen control. Flash does not support this.

Tool capabilities

What ships:

Function Calling
Structured Output
Search-as-a-tool
Code Execution

What is missing:

Computer Use — no screen control, no clicking, no form filling. If your agent operates a browser or desktop app, you still need GPT-5.5 for that part.

When to pick which model

Agent needs to call multiple tools in sequence?
  → Gemini 3.5 Flash

Agent needs to refactor code across a large repo?
  → Claude Opus 4.7

Agent needs to control a browser or desktop?
  → GPT-5.5

Need all three depending on the task?
  → Route through a unified gateway

API call example

Through EvoLink (single endpoint for Gemini, Claude, and GPT):

curl -X POST https://direct.evolink.ai/v1beta/models/gemini-3.5-flash:generateContent \
  -H "Authorization: Bearer YOUR_EVOLINK_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "List the top 3 files changed in the last commit and explain what each change does"}]
    }]
  }'

If you were using any previous Gemini model through EvoLink, swap the model ID. No other change needed.

The benefit: same API key and endpoint for Flash, Opus 4.7, and GPT-5.5. Switch model IDs depending on the task. One bill, automatic failover.

Full docs: EvoLink Gemini 3.5 Flash API Guide

Things to keep in mind

These are Google's benchmarks. Independent community testing will confirm or adjust. Take the exact numbers with normal benchmark skepticism.
Agent cost is not unit cost. A 20-step agent loop means 20 API calls. Fast and cheap per token is not the same as cheap per workflow run.
Dynamic Thinking adds reasoning tokens. The model thinks before answering. This increases output quality but also output token count. Watch your bills.
3.5 Pro is expected next month. If you need peak general reasoning from Google, it might be worth waiting.

Sources

Pick models by task, not by tier. Flash for tool orchestration. Opus for code rewrites. GPT for screen control. That is the state of play.

tags: gemini, ai-agents, llm, api, google-io

Codex Now Works from Your Phone — Plus Hooks and CI/CD Tokens

Evan-dong — Fri, 15 May 2026 07:57:10 +0000

Codex Now Works from Your Phone — Plus Hooks and CI/CD Tokens

I run Codex for long refactoring tasks. The annoying pattern: start a job, step away, come back to find Codex has been waiting 40 minutes for me to approve a permission check.

The May 2026 updates fix that, along with a few other gaps I cared about.

The Three Things That Matter

1. Mobile access (preview, May 14)

Codex is now available in preview on the ChatGPT mobile app for iOS and Android. Your phone connects to the Codex session running on your Mac — you review diffs, approve commands, switch models, and follow terminal output from wherever you are. The code stays on the host machine.

Setup: latest ChatGPT app + Codex for Mac → scan QR code to pair.

2. Hooks (GA, May 14)

You can now inject custom scripts at 6 points in the Codex loop. The one I found most useful: PreToolUse to scan Bash commands for credential patterns before they execute.

# ~/.codex/config.toml
[[hooks.PreToolUse]]
matcher = "^Bash$"

[[hooks.PreToolUse.hooks]]
type = "command"
command = "python3 ~/.codex/hooks/scan_credentials.py"
timeout = 30

The hook receives JSON on stdin with the command about to run, and can return {"decision": "block", "reason": "..."} to stop it.

Other hook events: SessionStart, PostToolUse, PermissionRequest, UserPromptSubmit, Stop. Enterprise teams can push managed hooks via requirements.toml.

Caveat: hooks do not intercept all shell calls yet per the docs.

3. Access tokens (Business/Enterprise, May 5)

If you run Codex in CI/CD, you no longer need to fake an interactive login. Access tokens carry workspace identity:

export CODEX_ACCESS_TOKEN="<token>"
codex exec --json "run tests and report coverage"

Business and Enterprise only. Tokens expire (configurable) and show up in governance logs under the creating user.

Also Shipped

Remote SSH (GA): connect Codex to managed dev environments through a relay — no public SSH port needed
HIPAA compliance: for eligible Enterprise workspaces in local environments

The Multi-Agent Problem Remains

These features make Codex better. But if you also use Claude Code and Gemini CLI, you still have three API keys, three dashboards, no fallback between them.

All three CLIs support custom endpoints:

# Codex: ~/.codex/config.toml
[api]
base_url = "https://api.evolink.ai/v1"

# Claude Code
export ANTHROPIC_BASE_URL="https://api.evolink.ai"

# Gemini CLI: ~/.gemini/.env
GOOGLE_GEMINI_BASE_URL=https://api.evolink.ai/

One gateway → unified cost, automatic fallback on 429/5xx, model switching via routing rules.

Setup guide for routing all three CLIs →

References

I Tried TencentDB Agent Memory — Here's What the Token Reduction Looks Like

Evan-dong — Fri, 15 May 2026 07:47:26 +0000

I Tried TencentDB Agent Memory — Here's What the Token Reduction Looks Like

The context window problem in long-running agents is familiar: by turn 20, you are paying for tool logs the agent does not need anymore. Truncation loses detail. Summarization compresses but also forgets.

Tencent Cloud open-sourced TencentDB Agent Memory (MIT license, May 2026), and it takes a different approach: offload the verbose stuff to local files, keep a Mermaid task graph in context, let the agent drill back in when it needs specifics.

The Architecture

Four memory layers, each traceable back to raw data:

L0 Conversation: raw dialogue + tool logs
L1 Atom: structured facts extracted every N conversations
L2 Scenario: aggregated solution patterns
L3 Persona: user behavior profiles built over time

The short-term trick: verbose tool output gets offloaded to refs/*.md files. In context, only a lightweight Mermaid graph remains. When the agent needs a specific output, it retrieves by node_id.

The Numbers

According to the project's benchmarks (long-horizon sessions, not isolated turns):

Task	Success Change	Token Change
WideSearch	33% → 50%	−61.38%
SWE-bench	58.4% → 64.2%	−33.09%
PersonaMem	48% → 76% accuracy	N/A

Biggest gains on WideSearch — makes sense, that is where context accumulates fastest. SWE-bench improvement is real but modest (+9.93%).

Important caveat: these are self-reported by the project team, not independently verified.

Quick Setup (OpenClaw)

openclaw plugins install @tencentdb-agent-memory/memory-tencentdb

// ~/.openclaw/openclaw.json
{
  "memory-tencentdb": {
    "enabled": true,
    "offload": { "enabled": true }
  }
}

openclaw gateway restart

That is it. SQLite + sqlite-vec by default, no external DB needed. The offload.enabled: true is what activates the Mermaid compression — without it you only get long-term memory.

Two Layers of Cost Optimization

Memory cuts tokens per call. But you are still paying the provider's per-token rate, and if the provider has an outage, the agent stalls.

If you route agent LLM calls through a gateway, you get a second optimization layer: model routing (pick the cheapest capable model per task), automatic fallback on 429/5xx, and a unified cost dashboard.

For Hermes, this means setting MODEL_BASE_URL to a gateway endpoint:

docker run -d --name hermes-memory \
  -e MODEL_BASE_URL=https://api.evolink.ai/v1 \
  -e MODEL_API_KEY=your-key \
  hermes-memory

Fewer tokens × lower cost per token = compounding savings.

More on unified API routing for multi-model apps →

Limitations

Only OpenClaw and Hermes are supported today
Offloading is off by default
SQLite is single-agent; concurrent access needs Tencent Cloud Vector DB backend
Benchmarks are project-reported

Codex vs Claude Code vs Cursor: What Changed in May 2026 and What Can Be Routed

Evan-dong — Thu, 14 May 2026 12:50:13 +0000

A common setup now is Codex CLI for scaffolding, Claude Code for refactoring, and Cursor for IDE or cloud-agent workflows. This month all three shipped infra updates — on different dates, solving different problems.

Here is what changed, what can be wired through one endpoint, and what has to remain separate.

The Updates

Codex CLI — Windows Sandbox (May 13)

Codex now has real OS-level sandboxing on Windows. Dedicated user accounts (CodexSandboxOffline/CodexSandboxOnline), per-account firewall rules, helper binaries for privilege boundaries. Linux already had seccomp/bubblewrap; Windows finally caught up.

Previously, Windows sandbox attempts used synthetic SIDs and proxy-based network blocking — programs could bypass them by implementing their own networking stack.

Claude Code — Doubled Five-Hour Rate Limits (May 6)

Anthropic doubled Claude Code's five-hour rate limits for Pro, Max, Team, and seat-based Enterprise plans. Also removed the peak hours limit reduction for Pro and Max.

This was announced May 6, a week before the other updates. If you were splitting refactoring tasks to stay under the five-hour cap, you have roughly 2x headroom.

Cursor — Cloud Agent Environments (May 13)

Cloud environments with multi-repo support, Dockerfile config with build secrets, layer caching (70% faster on cache hits), version history, rollback, scoped egress/secrets, audit logging.

Dockerfile auto-config is in private beta, rolling out to Enterprise teams.

Quick Comparison

	Codex	Claude Code	Cursor
Updated	May 13	May 6	May 13
What	Windows sandbox	2x five-hour limits	Cloud dev environments
Runs	Local sandbox	Local terminal	Cloud + IDE
Multi-repo	No	No	Yes
Isolation	OS-level	None	Cloud containers
Best for	Scaffolding, Windows	Refactoring, terminal	End-to-end delivery

The Problem When You Use More Than One

Multiple provider keys, billing dashboards, and rate-limit surfaces. When Claude Code hits its five-hour cap, no automatic fallback happens by default. When you want to compare spend across routable CLIs, you are exporting data from separate consoles.

One Gateway Setup

Point the routable CLIs at one endpoint:

# Codex: ~/.codex/config.toml
[api]
base_url = "https://api.evolink.ai/v1"

# Claude Code
export ANTHROPIC_BASE_URL="https://api.evolink.ai"
export ANTHROPIC_AUTH_TOKEN="your-evolink-key"

# Gemini CLI: ~/.gemini/.env
GEMINI_API_KEY=your-evolink-key
GOOGLE_GEMINI_BASE_URL=https://api.evolink.ai/

What you get: unified cost dashboard, automatic fallback on 429/5xx, model switching via routing rules.

Note: Cursor cloud environments use their own backend — not routable through third-party gateways yet. Local Cursor IDE completions can be routed.

Full walkthrough: One Gateway for 3 Coding CLIs

Watch Out For

Config precedence: env vars override config files. If you set ANTHROPIC_BASE_URL globally and have a project .claude/settings.json, behavior depends on tool version.
Auth errors: 401 from gateway usually means old provider key is still being sent. Restart terminal after env var changes.
Upstream limits still apply: gateway adds fallback, but Anthropic five-hour cap and OpenAI daily quotas are still upstream.

Sources

OpenAI: Codex Windows Sandbox (May 13)
Cursor: Cloud Agent Environments (May 13)
Anthropic: Higher Limits (May 6)

I Tried the Claude Code Skills Repo That Got 77K Stars — Here Is What Works and What Does Not

Evan-dong — Wed, 13 May 2026 12:13:27 +0000

I kept running into the same problem with coding agents: I would describe a task, the agent would build something, and it was not what I meant. Not broken — just off.

The fix turned out to be surprisingly low-tech. Matt Pocock published a repo of "skills" — small instruction files that go in your .claude directory and change how the agent approaches work. The repo exploded: 77,000+ stars, 6,700+ forks, #1 on GitHub Trending.

I installed it. Here is what I found.

Setup (About 60 Seconds)

npx skills@latest add mattpocock/skills

Pick the skills you want. Select /setup-matt-pocock-skills — it is the bootstrap.

Inside your agent:

/setup-matt-pocock-skills

It asks your issue tracker (GitHub / Linear / local files), triage labels, and docs folder. Done.

Works with Claude Code, Codex, Cursor, or anything that reads .claude/ directories.

The 4 Skills I Actually Use

There are 28 skills. I use 4 regularly.

`/grill-with-docs`

This is the best one. Before you start coding, the agent asks you detailed questions about what you are building. Edge cases, constraints, why you are doing it this way.

The output is a CONTEXT.md file — a shared vocabulary that the agent reads in every future session. One of my projects had a 15-word phrase that got replaced with "materialization cascade." Every session after that was shorter and more accurate.

`/tdd`

Forces test-driven development: tests first, implementation second, verification third. Works great on isolated functions. Gets annoying on complex UI where the tests are hard to specify upfront.

`/diagnose`

Structured debugging instead of the agent guessing. Most useful when the error message does not point to the real problem.

`/caveman`

Extreme concision. The agent says as little as possible and just executes. Perfect for experienced devs who already know what they want.

Everything Else (Quick Map)

Alignment: /grill-me (non-code version), /to-prd, /to-issues
Code quality: /prototype, /triage, /zoom-out
Workflow: /handoff, /write-a-skill, /review (WIP), /setup-pre-commit

Honest Limits

Skills are instructions, not plugins. They do not make the model smarter — they make the conversation more structured.
CONTEXT.md drifts. You need to update it as the project evolves, or re-run the grill.
Agent-agnostic = lowest common denominator. Skills work everywhere but cannot use agent-specific features like Claude Code's /goal.
28 skills is too many to learn at once. Start with the four above.

When It Gets Bigger

Once a team runs multiple agents on the same codebase, the next problem is not prompt quality — it is routing. Who uses which model, how much does each workflow cost, and where do the API keys live.

Skills handle the agent behavior side. For the model routing side, connecting Claude Code CLI to a gateway makes the access path concrete. The EvoLink Claude Code CLI guide documents that setup if your team is at that stage.

Who Should Use This

✅ Daily coding agent user who wants structured quality control
✅ Team with domain-specific terminology that confuses agents
✅ Multi-developer project using coding agents on the same repo
❌ One-off scripts or throwaway code
❌ Projects too small for shared language docs

mattpocock/skills on GitHub | skills.sh installer | Claude Code docs

tags: claude-code, ai, developer-tools, coding-agent

Stop Asking Claude Code for Markdown Specs. Ask for HTML Artifacts.

Evan-dong — Sat, 09 May 2026 09:30:17 +0000

Claude Code is very good at writing Markdown. That does not mean Markdown should be the default output for every task.

Thariq from the Claude Code team recently described a workflow where he increasingly asks Claude Code for HTML instead of Markdown. The reason is practical: long Markdown specs are easy to generate but hard to read. HTML can turn the same information into a navigable, visual, and sometimes interactive artifact.

When HTML Beats Markdown

Use HTML when the output is meant to be consumed by people, not maintained line by line in Git.

Good fits:

PR walkthroughs
design option comparisons
architecture explainers
onboarding docs
debugging reports
one-off planning tools
draggable prioritization boards

Keep Markdown for:

READMEs
changelogs
durable docs
API references
anything that needs clean Git diff review

Example: PR Review Artifact

Instead of:

Summarize this PR in Markdown.

Try:

Create a single self-contained HTML PR walkthrough.
Render the important diff areas with inline annotations.
Color-code findings by severity.
Add a manual verification checklist at the bottom.

That gives reviewers something closer to a focused review interface than a wall of bullets.

Example: Implementation Options

Generate 5 implementation approaches as one HTML file.
Use a comparison grid.
For each approach show:
- complexity
- migration risk
- test impact
- recommended use case

This is much easier to scan than five Markdown sections stacked vertically.

Trade-Offs

HTML is not always better.

Concern	Markdown	HTML
Git diffs	Great	Noisy
Long-term docs	Great	Mixed
Visual hierarchy	Limited	Strong
Interactivity	None	Possible
Sharing in browser	Requires renderer	Native

The rule I use: Markdown is the source. HTML is the reading surface.

Practical Prompt

Create a self-contained HTML explainer for this feature.
Audience: an engineer who has not seen this code before.
Include a visual summary, annotated code snippets, risks, and a next-step checklist.
Do not add external dependencies.

The real insight is not "HTML is better than Markdown." It is that AI-generated output does not have to be plain text. If the model can generate a useful interface, ask for the interface.

For teams building Claude Code workflows across multiple models, EvoLink provides unified API access to Claude and other frontier models.

OpenAI's New Realtime Voice Models Can Think, Translate, and Transcribe — Here's What Developers Need to Know

Evan-dong — Fri, 08 May 2026 13:36:06 +0000

OpenAI just shipped three realtime voice models through their API. One reasons at GPT-5 level during live calls. One translates 70+ languages in real time. One does streaming transcription. All available today.

Let me break down what matters for developers.

The Three Models

GPT-Realtime-2 handles voice conversations with GPT-5-level reasoning. The key difference from previous voice models: it can call tools mid-conversation without going silent. It narrates what it's doing while executing — OpenAI calls this "preamble."

GPT-Realtime-Translate does real-time voice translation. 70+ input languages, 13 output languages. End-to-end audio processing (no intermediate text step), which preserves tone and emotion.

GPT-Realtime-Whisper is streaming speech-to-text. Words appear as the speaker talks. Built for live captions and meeting transcription.

Integration Options

All three use the Realtime API with three connection methods:

WebRTC — browser-based, lowest latency
WebSocket — server-side, more control
SIP — telephony integration

GPT-Realtime-2: Voice Agents That Actually Work

If you've built voice agents before, you know the pain: tool calls create dead air. The user asks something that requires a database lookup, and the agent goes silent for 2-3 seconds. Feels broken.

GPT-Realtime-2 solves this with preamble — it talks through its actions while executing them. "Let me check your calendar... I see you have a meeting with Alex Kim in 12 minutes." The tool call happens in parallel with the speech.

Other developer-relevant specs:

128K context window (up from 32K)
Handles interruptions without losing context
Better instruction following for system prompts
Text tokens: $4/$16 per million (input/output)
Audio tokens: $32/$64 per million

GPT-Realtime-Translate: The $0.034/min Disruption

The translation model is priced at $0.034 per minute. For context, a human simultaneous interpreter costs $25-44 per minute.

Technical details:

Processes raw audio end-to-end (not cascaded speech-to-text-to-speech)
Preserves speaker emotion and tone
Works best with brief pauses between thoughts (labeled "turn-based" in docs)
Occasional hallucinations still occur
Supports language switching mid-stream

The end-to-end approach is what makes the quality difference. Traditional pipelines lose vocal characteristics at every stage. This model skips text entirely.

GPT-Realtime-Whisper: Streaming Transcription

If you need real-time captions or meeting transcription, this is the model. Low-latency streaming output as the speaker talks.

What You Can Build

The three models together cover the full voice infrastructure stack:

Customer support agents that can reason, look up accounts, and process requests — all by voice
Real-time translation layers for international meetings at 1/1000th the cost of human interpreters
Live captioning systems for streaming, conferences, or accessibility
Multilingual voice assistants that handle code-switching naturally
Telephony bots via SIP integration that feel like talking to a person

DEV Community: Evan-dong

# I Went Through 60 Curated Claude Fable 5 Cases So You Don't Have To — Here's What's Actually Useful

How each case is logged

Coding: screenshot → working clone

Agents: real incident diagnosis, not toy demos

The pattern worth stealing: "Relay"

The limits are documented too (this is the good part)

Reproducible prompts you can copy

Trying it yourself

One honest caveat

10 Claude Code Settings I Wish I'd Configured on Day One

1. Cap CLAUDE.md at 8,000 characters

2. settings.json — the permissions that change your rhythm

3. acceptEdits — enable it selectively, not globally

4. Hooks as guardrails — the 3 that earned their keep

5. Multi-model council for architecture decisions

6. "Effort levels" — match depth to the task

7. Spot context rot early and restart

8. The two-correction rule

9. Split settings by environment

10. Skills: lazy-load project-specific context

Where this leads

Takeaway

A Seedance 2.0 Prompt Template for More Controllable AI Video

The template

Why this helps

Example: action shot

Example: product ad

How I use the repo

Claude Code Dynamic Workflows: What I Learned From a 111-Agent Research Run

What I ran

The phase breakdown

The useful failure

Why workflows feel different from long chats

My checklist

Takeaway

I Generated a Full Brand Mockup Set from a Logo in 10 Minutes — Here's the Workflow

I Generated a Full Brand Mockup Set from a Logo in 10 Minutes — Here's the Workflow

The framework

The planning prompt

Test 1: Evolink (tech/API brand)

Test 2: MoriJoy (nature park brand)

What I learned

Try it

Gemini 3.5 Flash Just Shipped — Here's When to Use It (and When Not To)

Quick specs

Where Flash wins

Where Flash does NOT win

Tool capabilities

When to pick which model

API call example

Things to keep in mind

Sources

Codex Now Works from Your Phone — Plus Hooks and CI/CD Tokens

Codex Now Works from Your Phone — Plus Hooks and CI/CD Tokens

The Three Things That Matter

Also Shipped

The Multi-Agent Problem Remains

References

I Tried TencentDB Agent Memory — Here's What the Token Reduction Looks Like

I Tried TencentDB Agent Memory — Here's What the Token Reduction Looks Like

The Architecture

The Numbers

Quick Setup (OpenClaw)

Two Layers of Cost Optimization

Limitations

Links

Codex vs Claude Code vs Cursor: What Changed in May 2026 and What Can Be Routed

The Updates

Quick Comparison

The Problem When You Use More Than One

One Gateway Setup

Watch Out For

Sources

I Tried the Claude Code Skills Repo That Got 77K Stars — Here Is What Works and What Does Not

Setup (About 60 Seconds)

The 4 Skills I Actually Use

/grill-with-docs

/tdd

/diagnose

`/grill-with-docs`

`/tdd`

`/diagnose`

`/caveman`