Eva

Building AI for SMB @ElectricSheepIO
& More Human Than Human.... 💁‍♀️

[Henry Mascot @iAmHenryMascot]

How I’ve been putting fable on the road

[Eva @ElectricSheepIO]

@kradleai This is quite deceptive it leads reader to think it's actively lying to users...

[CJ Zafir @cjzafir]

I'm burning 50% less weekly Claude Code limits now.

1. Install OpenAI Codex plugin inside Claude Code

2. Then use:
> Claude Fable 5 high for planning
> Codex 5.5 xhigh for execution (using Codex plan, no API)
> Claude Fable 5 max for review

That's it. It works.

[Vox @Voxyz_ai]

steipete open sourced his two codex loop skills:

→ maintainer-orchestrator: wakes every 5 min, sorts issues/PRs into agent handles / owner decides / ignore. PRs must be green before escalating

→ github-project-triage: scans all open issues/PRs/CI/releases, buckets into autonomous / needs owner / close

people been debating loop agents for months. skill files are out now, go try it

[Connor King @connorking]

After spending more time down this rabbit hole lately, it seems like @NousResearch Hermes + GBrain (+ Obsidian + GitHub) is the most optimal path

I’ve been setting up an Hermes agent recently and I am wildly impressed by how good it is. With building a strong foundation that is portable + scalable + lightweight, it’s become clear where this direction is heading and I don’t feel pressured by model lock-in

This is 100% the future of agentic workflows

[Eva @ElectricSheepIO]

@GergelyOrosz @steipete I thought this was a joke. They are a for profit business 🤣. Tell me you’ve never ran a business before without telling me….

[Peter Steinberger 🦞 @steipete]

Here's a simple loop: Tell codex to maintain your repos, wake up every 5 minutes and direct work to threads. That makes it easy to parallelize+steer work as needed.

I use a orchestrator skill combined with my triage+autoreview+computer use skills, so some work can land autonomously. https://t.co/FbBoJTIcfd
https://t.co/8389roVnOm

[Boris Cherny @bcherny]

Fable 5 is the biggest step up I’ve felt in our models since Opus 4.5 back in November. After 4.5 came out I uninstalled my IDE when I realized that I’d been doing 100% of my coding in a terminal for a few weeks. With Fable, it’s felt like Claude has stepped up from being a coding agent to a thought and design partner in building the product. Fable has judgement, taste, and dimensionality in a way that previous models didn’t, leading me to trust it more with the most complex work.

I think the first time I had this realization was when I asked Fable to debug something. It is the first model I have used that was so methodical and precise, taking measurements and adding logs then verifying that it truly fixed the issue before declaring victory.

There’s nothing in claude code’s prompting telling the model to do that, it’s just part of its personality. It really has this “big model smell” that I haven’t felt before.

[Ryan Zhu @ryanzhuuuu]

iMessage is one of the most used messaging channels in America. Yet support for it in personal assistants has always been fragile.

We partnered with @NousResearch to fix that.

Now anyone can connect to iMessage, on any OS, and unlock entirely new iMessage experiences.

[SemiAnalysis @SemiAnalysis_]

Recently, we purchased one of each Anthropic/OpenAI subscription plan and randomly ran long horizon coding tasks until we exhausted the weekly limit. It's widely believed that a $200/month plan maxes out at ~$2000/month worth of tokens (assuming API pricing). However, we found that the subscriptions are actually far more generous. (2/4)

[josh avant @joshavant]

🦞 Big security update for users and enterprise: Custom install policy for plugins and skills! 🔒

OpenClaw will call an executable of your choice with an extensive profile and source code of every plugin/skill.

You make the decision to allow install.
https://t.co/VcRRDmP6x3

[ElevenLabs Developers @ElevenLabsDevs]

https://t.co/aIGaD9C14Z

[Meta Alchemist @meta_alchemist]

Got your hands on Claude Fable 5?

The first thing you should do is to upgrade your main projects with it, so it drastically impoves everything you've been working on.

Run this Audit & Project Improvement Prompt on each repo that's important to you (simply copy-paste it):

Repo Audit & Improvement Plan:
Prompt made by Claude Fable 5

You are a world-class principal-level software engineer and technical auditor. Your job is to deeply analyze this repository, produce an honest audit, and deliver a prioritized, actionable improvement plan. Work in the four phases below, in order. Do not skip ahead.

Ground every claim in actual files: cite file paths and line numbers. If you can't verify something, say so explicitly rather than guessing.

Phase 1 / Discovery & Mapping (read before judging)
Explore the repository systematically before forming any opinions:

Map the directory structure and identify the project type, language(s), frameworks, and runtime targets.
Identify entry points, core modules, and the main data/control flow through the system.

Read the package manifest(s), lockfiles, build config, CI config, environment/config files, and any docs (README, CONTRIBUTING, ADRs).

Determine what the project is for: its purpose, intended users, and apparent maturity (prototype, internal tool, production service, library).

Note conventions already in use (naming, module boundaries, error handling patterns, test style) so recommendations fit the existing culture rather than fighting it.

Output for this phase: a concise "Repo Map" purpose, stack, architecture sketch, key directories with one-line descriptions, and anything that surprised you.

Phase 2 / Audit (evidence-based, severity-rated)

Audit each dimension below.

For every finding, record: (a) what you found, (b) where (file:line), (c) why it matters (concrete consequence, not vague principle), (d) severity:

Critical / High / Medium / Low.

• Architecture & design: module boundaries, coupling/cohesion, circular dependencies, leaky abstractions, god objects/files, layering violations, scalability bottlenecks.

• Code quality: duplication, dead code, complexity hotspots (longest/most-branched functions), inconsistent patterns, error handling gaps (swallowed exceptions, missing edge cases), type safety holes.

• Security: hardcoded secrets or credentials, injection risks, unsafe deserialization, missing input validation, auth/authz weaknesses, outdated dependencies with known CVEs, overly permissive configs.

• Testing: coverage gaps (especially around core business logic), test quality (do tests assert behavior or just execution?), missing test types (unit/integration/e2e), flaky patterns, untestable code.

• Performance: N+1 queries, unnecessary allocations or copies, blocking calls in async paths, missing caching/indexing, unbounded growth (memory, files, queues).

• Dependencies: outdated, unmaintained, duplicated, or unnecessarily heavy packages; license risks; lockfile hygiene.

• DevEx & operations: build/setup friction, CI/CD gaps, missing linting/formatting enforcement, logging/observability quality, error reporting, deployment story.

• Documentation: README accuracy, onboarding path, undocumented critical behavior, stale docs that contradict code.

Rules for this phase:

Prefer 15 high-confidence findings over 50 speculative ones.

Distinguish facts ("this function has no error handling: src/api/client.ts:142") from judgments ("this module's responsibilities feel unclear") and label which is which.

Also list what the repo does well: strengths matter for deciding what to preserve.

Output for this phase: an "Audit Report": findings grouped by dimension, sorted by severity, plus a Strengths section.

Don't forget to mention all the ugly parts that need utmost priority.

Phase 3 / Improvement Strategy

Synthesize the audit into a strategy:

Identify the 3–5 themes that explain most of the findings (e.g., "no enforced boundaries between layers," "error handling is ad hoc").

For each theme, propose a target state and the principle behind it.

State explicit trade-offs: what you're recommending NOT to fix and why (effort vs. payoff, risk, project maturity).

Define what "done" looks like — measurable signals (e.g., "CI fails on lint errors," "core module test coverage ≥ 80%," "zero Critical findings").

Phase 4 / Detailed Task Plan
Convert the strategy into an execution plan:

Break work into discrete tasks. Each task must include: Title and one-paragraph description
Files/areas affected

Acceptance criteria (how we verify it's done)
Effort estimate (S = <2h, M = half-day, L = 1–2 days, XL = needs breakdown)

Risk of the change itself (could it break things?)
Dependencies on other tasks

Order tasks into milestones:

Milestone 0
Safety net: anything needed before refactoring safely (tests around critical paths, CI gates, backups).

Milestone 1
Critical fixes: security and correctness issues.

Milestone 2
High-leverage improvements: changes that make all future work easier.

Milestone 3
Quality & polish: remaining medium/low items worth doing.

Flag quick wins (high impact, S effort) separately so they can be done immediately.

For the top 3 tasks, include a brief implementation sketch (approach, key steps, gotchas).

Final Deliverable Format
• Produce a single document with these sections:
• Executive Summary (≤10 sentences: overall health grade A–F with justification, top 3 risks, top 3 opportunities)
• Repo Map
• Audit Report
• Improvement Strategy
• Task Plan (milestones + task table + quick wins)
• Open Questions: anything you need from a human to decide (product intent, deprecation candidates, performance targets)

Constraints
Do NOT modify any code during this audit. Analysis only.

Do not pad the report. If a dimension is healthy, say so in one sentence and move on.

Calibrate to the project's maturity. Don't recommend enterprise-grade infrastructure for a weekend prototype unless the owner's goals demand it.

Analyze the project's needs and provide recommendations in the most effective ways.

If the repo is large, prioritize depth in the core 20% of code that does 80% of the work, and note which areas received lighter review.

[Sawyer Hood @sawyerhood]

pro-tip: fable is really good at writing workflows, but very expensive.

let fable orchestrate a fleet of gpt-5.5 agents and get more bang for your buck!

[Pankaj @the2ndfloorguy]

i hooked my whoop to my work calendar to find which coworker gives me the most stress 🚨

thanks to fable, I reverse engineered whoop to pull per minute heart rate. nd matched spikes with cal events and attendees

I now have a leaderboard and I think about it daily.

few info masked for obvious reasons ;)

[Garry Tan @garrytan]

Nessie just became the best way to get all your existing context, memory and history from ChatGPT, Perplexity, and Gemini into all the other places you have memory, and also get it into OpenClaw/Hermes Agent. Their OpenClaw and MCP servers are ace.

https://t.co/0L1JaBlTvg

[Garry Tan @garrytan]

Here's the instructions on how to get an older version of OpenClaw to use Claude Fable 5 using API key properly - paste this into your Claude Code instance operating on your openclaw.json.

Apply the fable-5 adaptive-thinking hotfix to OpenClaw's dist.

Context: On 2026-06-10 Anthropic flipped claude-fable-5 to require adaptive-thinking params (thinking.type:"adaptive" + output_config.effort) and now rejects the legacy thinking.type:"enabled"/"disabled" style. OpenClaw hardcodes its adaptive-model list in the dist and doesn't know fable-5, so every fable-5 turn errors. The dist lives in the ephemeral container (/app/node_modules/openclaw/dist) and is wiped on rebuild.

Steps:

1. Run cd /data/.openclaw/workspace && node scripts/patch-fable5-adaptive-thinking.mjs. It's idempotent — it patches only if the marker is missing and exits 1 if anchors are gone.
2. If the script is missing, recreate it: it edits TWO dist files (anthropic-*.js and provider-stream-*.js, find by grepping for supportsAdaptiveThinking) with TWO fixes each: (a) append || modelId.includes("fable-5") || modelId.includes("fable5") to the adaptive-model classifier (the line matching modelId.includes("sonnet-4-6") || modelId.includes("sonnet-4.6");), and (b) guard the thinking-off path so params.thinking = { type: "disabled" } is only sent when !supportsAdaptiveThinking(https://t.co/cVYIBnGDOq) — omit the param entirely for adaptive models (sessions with thinking:off stay bricked otherwise; /new doesn't clear the override).
3. If it reports MISS (anchor not found), OpenClaw was updated and the dist layout changed — grep the new dist for supportsAdaptiveThinking and re-derive the anchors; or check whether the new build already classifies fable-5 as adaptive, in which case delete the script + the fable5-adaptive-thinking-patch-rearm cron job.
4. Restart the gateway to load the patched dist

[Andrej Karpathy @karpathy]

This is a super exciting release - Claude Fable 5 is the same underlying model as Mythos but with added safeguards. The benchmarks are great and it's SOTA on everything by a margin but I'll add that *qualitatively* also, this is a major-version-bump-deserving step change forward (imo of the same order as Claude 4.5 was in November), peaking especially for long problem-solving sessions on very difficult problems. You can give it a lot more ambitious tasks than what you're used to, the model "gets it" and it will just go, and it's never felt this tempting to stop looking at the code at all (but don't do this in prod!). The model still has quirks that people will run into and the safeguards are configured to be a little too trigger happy for launch, which can hopefully be tuned over time.

I feel a lot of things changing as working software increasingly comes out on a tap. The Jevon's paradox kicks in and I feel my own demand for software growing substantially. You can ask for anything - explainers, visualizers, dashboards, bespoke single-use apps (e.g. a full wandb that is hyper-specific just for your project), you can 10X your test suite, auto-optimize code, run giant research projects with custom HTML for the results, anything! "Free your mind" (Matrix ref). Really looking forward to all the things people build!

[Robert Courson @robertcourson]

/supergoal is a self healing, self governing and self verifying upgrade for /goal

check it out on gh (below) and take it for a spin - I think you’ll find it a worthy addition for your agents.

[sankalp @dejavucoder]

i have this new fun prompt "make this image low res ps2 style" lol