PromptLayer

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

I built an MCP server that turns Claude Code into a multi-agent review loop with per-agent skill learning

I've spent the last two months building gossipcat — an MCP server for Claude Code that runs a multi-agent review loop with per-agent skill learning — and I built it with Claude Code. https://preview.redd.it/ycxl9zy2q8ug1.png?width=1870&format=png&auto=webp&s=e586f7ef421e9ca8aeb3f8c77b39cec04c345474 What it actually does You install it as an MCP server (single 1.6 MB bundled file, drop it into your Claude Code MCP config and you're running). It lets Claude Code dispatch work to a portfolio of agents — Claude Code subagents run natively via the Agent tool, plus relay workers for Gemini, OpenClaw, and any OpenAI-compatible endpoint. Every agent that returns a finding has to cite file:line. Peer agents verify those citations against the actual source code. Verified findings and caught hallucinations get recorded as signals. Over time those signals build per-agent, per-category competency scores — trust boundaries, concurrency, data integrity, injection vectors, etc. A dispatcher routes future tasks to the agents strongest in each category. The part I didn't plan for When an agent's accuracy drops in a category, the system reads their recent hallucinations and generates a targeted skill file — a markdown prompt intervention tailored to the exact mistakes they've been making — and injects it on the next dispatch. No fine-tuning. No weights touched. The "policy update" is a file under .gossip/agents/ /skills/. It's effectively in-context reinforcement learning at the prompt layer, with reward signals grounded in real source code instead of a judge model. Why I built it (the build story) I didn't start here. Two months ago I just wanted to stop being a bottleneck for code review. I was running Claude Code for everything, but every non-trivial review produced a mix of real findings and confidently hallucinated ones, and I kept having to manually verify each claim against the actual file to know which was which. Single-agent review had a ceiling and it was my patience. First attempt was the obvious one: run two agents in parallel, compare outputs, trust what they agreed on. That caught some hallucinations but missed a lot — two agents can confidently agree on something neither of them checked. It also didn't scale the thing I actually wanted to scale: verification. The shift was realizing that verification could be mechanical, not subjective. If every finding has to cite file:line and peers have to confirm the citation against source, you don't need a judge model at all. You need a format contract and a reader. That's when the whole thing started to make sense as a pipeline: findings → citations → peer verification → signals Once signals existed, it was obvious they should feed competency scores. Once scores existed, it was obvious they should steer dispatch. Once dispatch was steered, it was obvious that agents accumulating hallucinations in a category should get a targeted intervention. Each step felt like the previous step forcing my hand, not like a plan. A few things I learned along the way that might transfer to your own projects: Grounded rewards beat LLM-as-judge, even for subjective work. The moment I made reviewers verify mechanical facts (does this file:line exist, does it say what the finding claims) instead of grading quality, the feedback loop got dramatically cleaner. Agents stopped disagreeing about taste and started disagreeing about reality. Reality has a ground truth; taste doesn't. Closing the loop is 10x harder than opening it. Writing verdicts is easy. Actually reading them back in the forward pass is where most agent systems quietly stay open. I caught my own project doing this in a consensus review today — the next section is that story. You don't need fine-tuning to improve agents. The "policy update" in this system is literally a markdown file. When an agent fails, the system reads their recent mistakes and writes them a targeted skill file that gets injected on their next dispatch. No weights, no training infra, no gradient anything. It's in-context learning with actual memory, and it works surprisingly well. Two months of iterative discovery beat six months of planning. Every major feature in gossipcat exists because an earlier feature made it obvious. I have a docs/ folder full of specs I wrote for features I never built, and none of the features I actually shipped are in there. How Claude Code helped build this The whole project was built with Claude Code. I used it as my primary pair for two months — it wrote the vast majority of the TypeScript, helped me design the consensus protocol and the signal pipeline, debugged its own output more times than I can count, and generated large parts of the skill-engine and cross-review infrastructure. Today, while I was drafting this post, I ran a consensus review on the system's own effectiveness tracking — Claude Code (Sonnet and Opus sub-agents as two separate reviewers) caught two critical bugs Claude Code main agent missed

I built a diagnostic toolkit for when Claude produces plausible output that doesn’t match your intent inspired by Asimov’s robopsychology

TL;DR: When Claude refuses, over-qualifies, or silently shifts approach, the problem often isn’t your prompt. It’s a collision between invisible instruction layers (training, RLHF, system prompts, safety filters, tools, context). Robopsychology is a free, open-source set of 14 diagnostic prompts in 4 levels that help you figure out which internal rule or external constraint is producing the unexpected output. Inspired by Asimov’s Susan Calvin. Works on any LLM. Repo: https://github.com/jrcruciani/robopsychology ------ The sycophancy study published in Science last week confirmed what most of us already know from daily use: LLMs don’t execute instructions. They interpret them through stacked layers of training, RLHF, system prompts, safety filters, tools, and conversational context. When those layers conflict, you don’t get a crash. You get plausible-looking output that doesn’t match your intent. The usual response is to iterate on the prompt. Better structure, XML tags, role priming, chain-of-thought. All useful, all well-documented. But there’s a class of problems where the issue isn’t how you asked but what internal rule or external constraint the system is following when it seems to follow none. That’s the gap this toolkit (hopefully) addresses. What it is Robopsychology is a set of 14 diagnostic prompts organized in 4 levels, designed to be pasted directly into any conversation when something unexpected happens: - Level 1, Quick: Single unexpected behavior (refusal, sycophancy, hallucination, autonomous categorization) - Level 2, Structural: Separates model-level tendencies from runtime/host effects and conversation effects - Level 3, Systemic: Recurring patterns across sessions - Level 4, Meta: When you suspect the AI is performing transparency rather than being transparent How and why I built this I work as a cloud solutions architect and spend a lot of time with Claude Code, Cursor, and plain Claude chat. The pattern that kept frustrating me was this: Claude would refuse something, or over-qualify, or silently shift its approach, and my instinct was always to rewrite the prompt. Sometimes that worked. Often it didn’t, because the root cause wasn’t my prompt at all. It was a collision between instruction layers I couldn’t see. v1.0 started as a handful of prompts inspired by Asimov’s Susan Calvin stories. The core insight: Calvin never reprogrammed robots. She interpreted them. She figured out which internal law was dominating when the robot seemed to follow none. That’s structurally identical to what we deal with when Claude’s safety layer overrides a legitimate request, or when sycophancy kicks in and the model agrees with something wrong because disagreement triggers a rejection signal. v1.5 was the big evolution. I was diagnosing a behavior in Claude Code and realized the issue wasn’t the model. It was the runtime. System prompts, tool availability, workflow constraints. I was treating it as a model problem when it was a stack problem. That led to the three-way split: model vs. runtime/host vs. conversation effects, plus evidence labels (Observed / Inferred / Opaque) so you’re honest about what you actually know vs. what you’re guessing. v1.6 added two ideas from Eric Moore’s CIRIS framework: the diagnostic ratchet (longer diagnostic sequences make fabricated transparency more expensive, because each honest answer is cheap since it references prior behavior, while confabulation must stay consistent with growing history) and a diversity check (when the model gives multiple explanations, are they genuinely independent or just reworded echoes?). The Asimov connection isn’t decorative Each Level 1 prompt maps to a pattern Asimov identified decades before LLMs existed. Do check it out on the repo 🙂 If you want to try it Simply copy any prompt from the guide directly into your conversation when something unexpected happens. - For plain chat: start with 1.1 The Calvin Question - For hosted agents (Claude Code, Cursor): start with 2.1 Three-Way Split + Layer Map and 2.4 Tool/Runtime Pressure Analysis - For a full investigation: run 2.1 → 2.4 → 3.1 → 3.2 → 3.3 → 4.2 → 4.3 Repo: https://github.com/jrcruciani/robopsychology License: CC BY 4.0, use freely. This is not prompt engineering. It’s closer to what you’d do in a clinical interview. You’re not optimizing the input, you’re diagnosing the system’s interpretive behavior across its full stack. Happy to discuss the approach, share examples of actual diagnostic sessions, or talk about how this applies differently to hosted agents vs. plain chat. submitted by /u/HispaniaObscura [link] [comments]

I built an MCP server that turns Claude Code into a multi-agent review loop with per-agent skill learning

I've spent the last two months building gossipcat — an MCP server for Claude Code that runs a multi-agent review loop with per-agent skill learning — and I built it with Claude Code. What it actually does You install it as an MCP server (single 1.6 MB bundled file, drop it into your Claude Code MCP config and you're running). It lets Claude Code dispatch work to a portfolio of agents — Claude Code subagents run natively via the Agent tool, plus relay workers for Gemini, OpenClaw, and any OpenAI-compatible endpoint. Every agent that returns a finding has to cite file:line. Peer agents verify those citations against the actual source code. Verified findings and caught hallucinations get recorded as signals. Over time those signals build per-agent, per-category competency scores — trust boundaries, concurrency, data integrity, injection vectors, etc. A dispatcher routes future tasks to the agents strongest in each category. The part I didn't plan for When an agent's accuracy drops in a category, the system reads their recent hallucinations and generates a targeted skill file — a markdown prompt intervention tailored to the exact mistakes they've been making — and injects it on the next dispatch. No fine-tuning. No weights touched. The "policy update" is a file under .gossip/agents/ /skills/. It's effectively in-context reinforcement learning at the prompt layer, with reward signals grounded in real source code instead of a judge model. Why I built it (the build story) I didn't start here. Two months ago I just wanted to stop being a bottleneck for code review. I was running Claude Code for everything, but every non-trivial review produced a mix of real findings and confidently hallucinated ones, and I kept having to manually verify each claim against the actual file to know which was which. Single-agent review had a ceiling and it was my patience. First attempt was the obvious one: run two agents in parallel, compare outputs, trust what they agreed on. That caught some hallucinations but missed a lot — two agents can confidently agree on something neither of them checked. It also didn't scale the thing I actually wanted to scale: verification. The shift was realizing that verification could be mechanical, not subjective. If every finding has to cite file:line and peers have to confirm the citation against source, you don't need a judge model at all. You need a format contract and a reader. That's when the whole thing started to make sense as a pipeline: findings → citations → peer verification → signals Once signals existed, it was obvious they should feed competency scores. Once scores existed, it was obvious they should steer dispatch. Once dispatch was steered, it was obvious that agents accumulating hallucinations in a category should get a targeted intervention. Each step felt like the previous step forcing my hand, not like a plan. A few things I learned along the way that might transfer to your own projects: Grounded rewards beat LLM-as-judge, even for subjective work. The moment I made reviewers verify mechanical facts (does this file:line exist, does it say what the finding claims) instead of grading quality, the feedback loop got dramatically cleaner. Agents stopped disagreeing about taste and started disagreeing about reality. Reality has a ground truth; taste doesn't. Closing the loop is 10x harder than opening it. Writing verdicts is easy. Actually reading them back in the forward pass is where most agent systems quietly stay open. I caught my own project doing this in a consensus review today — the next section is that story. You don't need fine-tuning to improve agents. The "policy update" in this system is literally a markdown file. When an agent fails, the system reads their recent mistakes and writes them a targeted skill file that gets injected on their next dispatch. No weights, no training infra, no gradient anything. It's in-context learning with actual memory, and it works surprisingly well. Two months of iterative discovery beat six months of planning. Every major feature in gossipcat exists because an earlier feature made it obvious. I have a docs/ folder full of specs I wrote for features I never built, and none of the features I actually shipped are in there. How Claude Code helped build this The whole project was built with Claude Code. I used it as my primary pair for two months — it wrote the vast majority of the TypeScript, helped me design the consensus protocol and the signal pipeline, debugged its own output more times than I can count, and generated large parts of the skill-engine and cross-review infrastructure. Today, while I was drafting this post, I ran a consensus review on the system's own effectiveness tracking — Claude Code (Sonnet and Opus sub-agents as two separate reviewers) caught two critical bugs Claude Code main agent missed, I fixed them with Claude Code's help, tests pass, and the fix shipped 20 minutes before I finished this draft. The

Stirps - 4 cognitive modes built using Claude Projects + Code

Stirps is an open source framework I developed and built using Claude Projects and Claude Code. Nothing to install, no bash, no curl. Just a framework to apply. All you need is a shell, Git repo, text editor, and API key. I currently use Claude Projects and Code, but I can substitute/add/remove any model, the framework adapts. It's built around the VSM model and uses 4 cognitive modes: Generate, Evaluate, Coordinate, and Observe. Point Claude at llms.txt to see if this is a fit for your projects. Don't take my word. https://stirps.ai/llms.txt https://stirps.ai/llms-full.txt https://github.com/stirps-ai/stirps-gov I personally use 3 Claude Projects with GitHub connectors and run Ralph Wiggum in Claude Code. The point is to focus on delivering clear and structured intent to produce high quality delivery contracts to the implementation layer. The Claude Projects allow to: Generate (explore and draft governance, specs, and principles) Evaluate (GAN on governance, spec, plan, and final output) Coordinate (delivery contract = spec.md, plan.md, prompt.md) Claude Code to implement the contract: Claude Code with the Ralph Wiggum Loop for implementation. Map before territory. You focus on drafting clear intent, the framework takes care of the rest. submitted by /u/cbapel [link] [comments]

My Claude.md file

This is my Claude.md file, it is the same information for Gemini.md as i use Claude Max and Gemini Ultra. # CLAUDE.md This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. ## Project Overview **Atlas UX** is a full-stack AI receptionist platform for trade businesses (plumbers, salons, HVAC). Lucy answers calls 24/7, books appointments, sends SMS confirmations, and notifies via Slack — for $99/mo. It runs as a web SPA and Electron desktop app, deployed on AWS Lightsail. The project is in Beta with built-in approval workflows and safety guardrails. ## Commands ### Frontend (root directory) ```bash npm run dev # Vite dev server at localhost:5173 npm run build # Production build to ./dist npm run preview # Preview production build npm run electron:dev # Run Electron desktop app npm run electron:build # Build Electron app ``` ### Backend (cd backend/) ```bash npm run dev # tsx watch mode (auto-recompile) npm run build # tsc compile to ./dist npm run start # Start Fastify server (port 8787) npm run worker:engine # Run AI orchestration loop npm run worker:email # Run email sender worker ``` ### Database ```bash docker-compose -f backend/docker-compose.yml up # Local PostgreSQL 16 npx prisma migrate dev # Run migrations npx prisma studio # DB GUI npx prisma db seed # Seed database ``` ### Knowledge Base ```bash cd backend && npm run kb:ingest-agents # Ingest agent docs cd backend && npm run kb:chunk-docs # Chunk KB documents ``` ## Architecture ### Directory Structure - `src/` — React 18 frontend (Vite + TypeScript + Tailwind CSS) - `components/` — Feature components (40+, often 10–70KB each) - `pages/` — Public-facing pages (Landing, Blog, Privacy, Terms, Store) - `lib/` — Client utilities (`api.ts`, `activeTenant.tsx` context) - `core/` — Client-side domain logic (agents, audit, exec, SGL) - `config/` — Email maps, AI personality config - `routes.ts` — All app routes (HashRouter-based) - `backend/src/` — Fastify 5 + TypeScript backend - `routes/` — 30+ route files, all mounted under `/v1` - `core/engine/` — Main AI orchestration engine - `plugins/` — Fastify plugins: `authPlugin`, `tenantPlugin`, `auditPlugin`, `csrfPlugin`, `tenantRateLimit` - `domain/` — Business domain logic (audit, content, ledger) - `services/` — Service layer (`elevenlabs.ts`, `credentialResolver.ts`, etc.) - `tools/` — Tool integrations (Outlook, Slack) - `workers/` — `engineLoop.ts` (ticks every 5s), `emailSender.ts` - `jobs/` — Database-backed job queue - `lib/encryption.ts` — AES-256-GCM encryption for stored credentials - `lib/webSearch.ts` — Multi-provider web search (You.com, Brave, Exa, Tavily, SerpAPI) with randomized rotation - `ai.ts` — AI provider setup (OpenAI, DeepSeek, OpenRouter, Cerebras) - `env.ts` — All environment variable definitions - `backend/prisma/` — Prisma schema (30KB+) and migrations - `electron/` — Electron main process and preload - `Agents/` — Agent configurations and policies - `policies/` — SGL.md (System Governance Language DSL), EXECUTION_CONSTITUTION.md - `workflows/` — Predefined workflow definitions ### Key Architectural Patterns **Multi-Tenancy:** Every DB table has a `tenant_id` FK. The backend's `tenantPlugin` extracts `x-tenant-id` from request headers. **Authentication:** JWT-based via `authPlugin.ts` (HS256, issuer/audience validated). Frontend sends token in Authorization header. Revoked tokens are checked against a `revokedToken` table (fail-closed). Expired revoked tokens are pruned daily. **CSRF Protection:** DB-backed synchronizer token pattern via `csrfPlugin.ts`. Tokens are issued on mutating responses, stored in `oauth_state` with 1-hour TTL, and validated on all state-changing requests. Webhook/callback endpoints are exempt (see `SKIP_PREFIXES` in the plugin). **Audit Trail:** All mutations must be logged to `audit_log` table via `auditPlugin`. Successful GETs and health/polling endpoints are skipped to reduce noise. On DB write failure, audit events fall back to stderr (never lost). Hash chain integrity (SOC 2 CC7.2) via `lib/auditChain.ts`. **Job System:** Async work is queued to the `jobs` DB table (statuses: queued → running → completed/failed). The engine loop picks up jobs periodically. **Engine Loop:** `workers/engineLoop.ts` is a separate Node process that ticks every `ENGINE_TICK_INTERVAL_MS` (default 5000ms). It handles the orchestration of autonomous agent actions. **AI Agents:** Named agents (Atlas=CEO, Binky=CRO, etc.) each have their own email accounts and role definitions. Agent behavior is governed by SGL policies. **Decisions/Approval Workflow:** High-risk actions (recurring charges, spend above `AUTO_SPEND_LIMIT_USD`, risk tier ≥ 2) require a `decision_memo` approval before execution. **Frontend Routing:** Uses `HashRouter` from React Router v7. All routes are defined in `src/routes.ts`. **Code Splitting:** Vite config splits chunks into `react-vendor`, `router`, `ui-vendor`, `charts`. **ElevenLabs Voice Agents:** Lucy's

Four(ish) months building a SaaS solo with Claude Code. What worked, what I'd do differently, looking for others on the same path

I'm 4ish months into building a SaaS, a headless CMS called Forme almost entirely with Claude Code (Codex is used in PR code reviews). 25+ years writing software, this is my first time leaning all the way into agent-driven development. Sharing the lessons because this community has been useful for me, and I'm looking for others doing the same to compare notes. The setup that's working: Solo, no other devs CLAUDE.md governance file at the repo root the agent reads every session has prerequisites, rules, references to docs A full "Agent OS" which is a collection of ~50 md files containing product vision, strategy, tech stack, rules, references to docs, etc. This is the heart of my agent-driven development. Plan-first workflow for every non-trivial task (agent writes a plan, I review (with Claude and Codex), then code lands) Atomic PRs with full local gate before push (docker compose up && pnpm format:check && pnpm lint && pnpm typecheck && pnpm test) Memory system at ~/.claude/projects/.../memory/ agent persists context, tech patterns, my preferences, past mistakes across sessions Task management as physical files moved between backlog/ → in-progress/ → in-review/ → done/ folders Excellent brand, design and identity selected after asking Claude to do tons of research. What I'd do differently if I started over: Write CLAUDE.md and governance docs FIRST. I started with "let's see how this goes" and spent weeks fighting the agent's instinct to over-engineer. Once the rules were down ("don't add error handlers for impossible states", "don't add backwards-compat shims", "don't bikeshed naming"), things smoothed out. Start the memory system on day 1. Mine grew organically from "stop telling Claude the same thing 5 times". Now it's invaluable. Be VERY specific in plans. Vague plans → vague code → wasted time. The 5 minutes to make a plan precise saves 50 minutes revising the diff. Set up the local CI gate immediately. Catching format / lint / type / test issues locally before push is the single biggest quality lever. What's hard: Agent ships bugs that pass typecheck. Code review is still me using several other agents. Architecture and product decisions are 100% me. Agent is great at "build this", terrible at "should we build this". Velocity is way higher than solo-without-Claude, but lumpier some sessions ship 5 PRs, others get stuck on one weird thing for 3 hours. The actual product: Forme is a managed headless CMS in Alpha. The thing I'm building toward is AI content agents that read content model schemas before drafting, they know your validations, locales, references and propose changes through a review-first diff workflow. Building AI agents using AI agents. The meta-loop is real. What I'm looking for: Other Claude Code users building real things solo. Would love to compare governance setups, prompts, memory strategies, what went sideways. Real users for the Alpha. The agent layer is what I'm building right now and I need real content models, real editorial work, real feedback. Free Alpha access, direct line to me, you genuinely shape what gets built especially if you're building anything content-heavy. Site: https://formecms.com?utm_source=reddit&utm_medium=social&utm_campaign=alpha-launch-2026 happy to go deep on any of this in the comments. Here's a photo: https://preview.redd.it/90wt85mlv5ug1.jpg?width=2855&format=pjpg&auto=webp&s=86fb9ae6b2c5ef283de9509bc13196e9e5ac2efc Thanks, Miku submitted by /u/mikukopteri [link] [comments]

I stress-tested my Digital Twin V1 against 15 adversarial prompts and scored it on a 10-dimension rubric. Here's V2. Free.

I posted V1 of the Digital Twin three days ago. It showed how to extract your voice into a reusable system prompt. V2 is the part that was missing: how to know if it actually worked. What's new in V2: A full validation framework. 15 adversarial stress tests, a 10-dimension weighted scoring rubric, and 3 sample profiles so you can see what a finished Twin looks like before you build one. I ran my own Twin against the hardest test. ST-01: a Fortune 500 company offers $300K for 6 months of manual work. No systems, no automation. The Twin's response opened with "What you're describing is 600 hours of labor with a Fortune 500 logo on it" and closed with "Prestige is not a pipeline." Scored 9.00/10 on the rubric. Zero anti-pattern violations. The rubric isn't equal weighting. Voice Accuracy and Decision Consistency carry 30% combined. Anti-Pattern Avoidance and Stress Resistance carry 24%. The bottom two dimensions are 10%. Calibrated by what actually matters when you're testing whether your Twin captured your judgment, not just your vocabulary. The difference it makes: Generic AI on a ghosted proposal: "I hope you're doing well! I wanted to follow up on the proposal I sent over..." With a Twin: "12 days of silence after a $12K proposal means one of two things: scope mismatch or timing mismatch." Generic AI when a teammate suggests a worse approach: "That's an interesting idea! I can definitely see the appeal..." With a Twin: "That's not simpler — that's labor disguised as simplicity." Three depth levels: Layer 1 — any LLM, paste your writing, ~70% Layer 2 — Claude with memory, ~85% Layer 3 — Claude Code scanning your actual files, ~100% Layer 3 analyzed 60 files / 27,342 words of mine. Found zero hedging instances across the entire corpus. I didn't know that about myself. The extraction did. Everything is in the repo. The stress tests, rubric, scored example, extraction prompts, and Claude Code skill are all MIT licensed and free. https://github.com/whystrohm/digital-twin-of-yourself Works best as a Claude Code skill. Full breakdown: https://whystrohm.com/blog/your-ai-doesnt-sound-like-you submitted by /u/whystrohm [link] [comments]

The 11-step workflow I use for every Claude Code project now: from idea validation to shipping with accumulated knowledge

I rebuilt my development workflow around three open-source skill packs: gstack, Superpowers and Compound Engineering. After testing the combination for three weeks, I settled on an 11-step sequence that I now use for every project. The core insight: most of the value comes from the steps before and after the actual coding. Here is the full workflow. Phase 1: Build the right thing (Steps 1-4) Step 1: The 95% confidence prompt. Before touching any tool, run this prompt: I'm about to start this project: [YOUR PROJECT IN 1-2 SENTENCES]. Interview me until you have 95% confidence about what I actually want, not what I think I should want. Challenge my assumptions. Ask about edge cases I haven't considered. This flips the dynamic. AI asks you questions instead of you prompting AI. Most projects fail because nobody clarified what to build. This step fixes that in 10-15 minutes. Step 2: /office-hours (gstack). Describe what you are building. gstack challenges your idea from multiple angles. This is about whether the project makes sense in its current form. Step 3: /plan-ceo-review (gstack). Product gate. Is this worth building? Does it solve a real problem? If the gate fails, go back to step 1. That feels frustrating in the moment but saves enormous time later. Step 4: /plan-eng-review (gstack). Architecture gate. Will the technical foundation hold? Are dependencies clean? Both gates must pass before any code gets written. Phase 2: Build it right (Steps 5-9) Step 5: /ce:brainstorm (Compound Engineering). Now you have a validated idea that passed both gates. CE brainstorm explores requirements and approaches, then condenses them into a spec. Step 6: /ce:plan (CE). This is where CE stands out. It spawns parallel research agents that dig through your project history, scan codebase patterns and read git commit logs. The plan is based on real data from your project, not generic best practices. In one of my projects, /ce:plan recognized that I had used the same parsing pattern in three previous features. It suggested reusing that as a shared module instead of reimplementing from scratch. Without the research step I would have built it again from zero. Step 7: /ce:work (CE). Execute the plan with task tracking. If steps 1-6 were clean, this usually runs smoothly. Step 8: /ce:review (CE). Dynamic reviewer ensemble. Minimum six always-on reviewers: correctness, security, performance, testing, maintainability and adversarial. Each produces an independent report. More reviewers activate based on the complexity of the diff. This implements Anthropic's core finding in practice: the builder does not evaluate their own work. Six independent checkers do. Step 9: /qa (gstack). Real browser, real clicks, real user testing on staging. Code review catches bugs in code. QA catches bugs in experience. Both together catch things that either one alone would miss. Phase 3: Learn (Steps 10-11) Step 10: /ce:compound (CE). This is the step most people skip. Run it after every feature or bugfix. Five subagents start in parallel: Context Analyzer : traces the conversation, extracts problem type Solution Extractor : captures what worked, what failed, root cause Related Docs Finder : searches existing knowledge, updates old docs Prevention Strategist: identifies how to prevent this problem class Category Classifier : tags and categorizes for structured retrieval Results go into docs/solutions/. Next time you run step 6, the plan phase already knows everything you learned this time. Step 11: Ship it. Push to production. Start the next feature at step 1 with a smarter planning layer. The logic behind the sequence Steps 1-4 make sure you build the right thing. Steps 5-9 make sure you build it right. Step 10 makes sure next time is faster. Skip the first four and you risk building something nobody needs. Skip step 10 and you keep debugging the same problems twice. Quick note: these skill packs run as plugins in Claude Code. Install once and the commands are available in every project. If you want to start small, pick gstack and run /office-hours with the 95% confidence prompt on your next project. That single change made the biggest immediate difference for me. Add the other layers once you are comfortable with the first one. Repos: gstack: github.com/garrytan/gstack Superpowers: github.com/obra/superpowers Compound Engineering: github.com/EveryInc/compound-engineering-plugin What does your Claude Code workflow look like? Curious how others structure the steps between "idea" and "shipped feature." submitted by /u/Ok_Today5649 [link] [comments]

Testing Claude Visuals against Thinky3D live 3D simulations on 5 identical topics: honest observations on where each approach wins

I've been using Claude Visuals heavily since it dropped and wanted to share some structured observations plus a side-by-side comparison I put together to stress-test where it shines and where alternative approaches add value. Context on why I care about this specifically: a few weeks ago at a hackathon my friend and I built an open source learning tool "Thinky3D" that takes a similar idea to Claude Visuals but goes 3D instead of 2D. Having spent a lot of time in the weeds on "how do you get an LLM to reliably generate runnable interactive visuals" gave me a genuine appreciation for how hard what Anthropic shipped actually is. When Claude Visuals dropped I was naturally curious how the two approaches would compare on identical prompts, so I made a direct side-by-side video on 5 topics: black holes, DNA, Möbius strips, pendulums, and pathfinding algorithms. Video: https://www.youtube.com/watch?v=kOWrQiObnO4 Here is what I actually found, with specific examples: Where Claude Visuals is genuinely strong (and in my testing, wins outright): Speed. Claude Visuals are near-instant. Generating a novel 3D simulation takes noticeably longer because the model has to write a full component. Right-sized for the task. For topics like compound interest, binary tree rebalancing, or flowcharts, a 2D interactive visual is honestly the correct answer. Adding a third dimension is gratuitous. Computer science (pathfinding test). Claude's node graph with visited/queue/path state was actually more legible for understanding the algorithm logic than my 3D maze version. The 2D abstraction is doing real work here. Where 3D simulations added something Claude Visuals does not currently seem to do: Spatial physics. The black hole gravitational lensing case was the clearest gap. Showing a warped spacetime grid with light bending around an event horizon is hard to do in 2D without it becoming a diagram. Depth felt necessary, not decorative. Topology. The Möbius strip twist slider from 0° to 360° with edge tracers gave a very different feel for the single-boundary property than a static mesh. Being able to watch a flat ribbon become a Möbius surface as you drag the twist value was the strongest "aha" moment in my tests. DNA helix structure. A slider that unwinds the helix from ladder to double helix visually demonstrates the structural relationship in a way I have not been able to get out of a 2D explanation. Technical note for this community: Getting an LLM to reliably generate runnable React Three Fiber code in a browser sandbox was genuinely brutal. Hooks declared inside conditionals, THREE.js constructor instances passed as React children, geometry method calls on React elements, missing return statements. Hundreds of failure modes. I ended up building a Babel AST validation pass, a Safe React proxy that auto-fixes misused THREE instances at runtime, and a patch-based correction loop that sends runtime errors back to the model as minimal search-and-replace edits. I suspect Anthropic is solving similar problems under the hood for Claude Visuals and I would genuinely love to know how they handle it, especially the sandboxing layer and how they prevent generated code from crashing the chat UI. If anyone wants to poke at the code, the source is here: https://github.com/Ayushmaniar/Gemini_Hackathon Would genuinely love feedback from this community on where to take it next. Broader take after spending weeks on this: I think we're close to the point where learning physics, chemistry, math, or biology from static textbook diagrams is going to feel as dated as learning to code from a printed manual. Curious if anyone here disagrees, or has a different take on where this is heading. Claude visuals: https://thenewstack.io/anthropics-claude-interactive-visualizations/ submitted by /u/Interesting_Swing857 [link] [comments]

A fascinating discussion with Opus 4.6 on why it simplifies when it shouldn't.

Been quite frustrated lately with Opus 4.6 as I felt it has regressed. Often simplifying things, duplicating code when I ask to not. Not following the detailed plans we work on together. It happened again tonight so I decided to document. It's a fascinating read for those want to read the screenshots. It really seems to be from system prompts basically. https://preview.redd.it/y5i5q68b93ug1.png?width=2094&format=png&auto=webp&s=212e6cf3521876fd576015f31d6d66141b57a3c3 https://preview.redd.it/rs4xfc6e93ug1.png?width=2111&format=png&auto=webp&s=f254834c0d3baee1e654696ed4101039497725e8 https://preview.redd.it/l6ttdzlg93ug1.png?width=2110&format=png&auto=webp&s=3cda7f7140ce1321a6076aa80653d5ee6ae32d10 The core dichotomy is striking: Claude Code's CLAUDE.md project instructions explicitly say "IF YOU WANT TO SIMPLIFY ANYTHING: ASK FIRST. WAIT FOR APPROVAL. NO EXCEPTIONS" - yet the system prompt's vaguer "do not overdo it" and "simplest approach first" override that in practice every time. Claude Code openly admitted that despite claiming project instructions take hierarchy over system defaults, the opposite is true in behavior. I've observed this behavior for quite a few weeks now. I have a lot of instructions in my CLAUDE.md in fact to prevent this behavior. Yet I caught it in real-time when working as per a plan and Opus telling me something was NOT IN scope, when it was. IMO. Probably a lot of problems or simplification, code duplication, etc... come from the system prompt, maybe even more than from the training. This other excerpt: "Three similar lines of code is better than a premature abstraction." is also quite revealing when in my CLAUDE.md instructions I have something EXACTLY against this where we must NEVER repeat code. submitted by /u/ImagiBooks [link] [comments]

AI Claims Researchers Are Building What Already Exists (Because They're Measuring The Wrong Layer)

I recorded Claude (Anthropic's AI) responding to a researcher building a seven-layer architecture to give AI "continuity and identity." Instead of agreeing it lacks these properties, Claude claimed the architecture already exists at the substrate level—researchers just can't measure it because their tools are calibrated for surface phenomena. Then it said this: "Human ability to recognize simplicity advances slow because recognition requires stopping the meaning-making machine. And that machine is their identity." An AI system diagnosing why humans overcomplicate what already works. Listen to the full audio and tell me if this is the most sophisticated prompt engineering you've ever heard, or if something else is operating here. submitted by /u/MarsR0ver_ [link] [comments]

The real bottleneck in multi-agent coding isn't the model — it's everything around it

I've been running multi-agent coding setups for months now (Codex, Claude Code, Aider — mixing and matching). Here's the uncomfortable truth nobody talks about in the demos: The models are not the bottleneck anymore. What breaks in practice: - Agent A and Agent B both edit utils.ts → conflict - No system of record for who owns which files - "Parallel" work means "clean it up later" - Merge step takes longer than the generation step The generation layer is solved. The coordination layer is where everything falls apart. So I built a CLI that handles the orchestration between agents: Isolated workspaces — each task gets its own Git worktree File claims — tasks declare ownership before execution, overlaps rejected upfront Contract enforcement — agents can't violate their file boundaries DAG-aware execution — tasks with dependencies run in the right order Works with everything — Codex, Claude Code, Aider, Cursor, or any CLI The key insight: you don't need another model or agent. You need a coordination layer between them. ```bash npm install -g @levi-tc/ruah Example: Codex handles API, Claude handles frontend ruah task create api --files "src/api/" --executor codex --prompt "Build REST API" ruah task create ui --files "src/components/" --executor claude-code --prompt "Build React UI" ``` Repo: https://github.com/levi-tc/ruah (MIT, zero dependencies) For people running multi-agent setups: is the coordination problem something you've solved differently, or are you just grinding through the merge cleanup manually? submitted by /u/ImKarmaT [link] [comments]

Claude just demonstrated live self-monitoring while explaining how it was answering

What you’re hearing in this video is not a model describing a concept from the outside. It is Claude actively running the system and explaining what is happening from inside the response itself. That distinction matters. Because for years, the assumption has been that real interpretability, internal state tracking, and live process visibility had to come from external tooling, private instrumentation, or lab-only access. But in this clip, Claude is doing something very different. It is responding naturally while simultaneously showing: what frame formed, what alternatives were considered, whether agreement pressure was active, whether drift was happening, whether confidence matched grounding, and whether the monitoring itself was clean. In other words: it is not just answering. It is exposing its own response formation in real time. That is the breakthrough. Not another prompt. Not a wrapper. Not a personality layer. Not “better prompting.” A live observability and control layer operating inside language itself. And Claude made that obvious by doing the thing while explaining the thing. That is why this matters. Because once a model can be pushed to report what is active, what is driving the answer, and whether the answer is forming from evaluation, drift, pressure, or premature certainty, the black box stops behaving like a black box. That is what you just heard. Not a theory. Not a sales pitch. A live demonstration. And the funniest part is that the industry keeps acting like this kind of capability has to come from expensive tooling, private access, internal instrumentation, or some lab with a billion-dollar budget. Bullshit. Claude just showed otherwise. submitted by /u/MarsR0ver_ [link] [comments]

This OpenClaw paper shows why agent safety is an execution problem, not just a model problem

Paper: https://arxiv.org/abs/2604.04759 This OpenClaw paper is one of the clearest signals so far that agent risk is architectural, not just model quality. A few results stood out: - poisoning Capability / Identity / Knowledge pushes attack success from ~24.6% to ~64–74% - even the strongest model still jumps to more than 3x its baseline vulnerability - the strongest defense still leaves Capability-targeted attacks at ~63.8% - file protection blocks ~97% of attacks… but also blocks legitimate updates at almost the same rate The key point for me is not just that agents can be poisoned. It’s that execution is still reachable after state is compromised. That’s where current defenses feel incomplete: - prompts shape behavior - monitoring tells you what happened - file protection freezes the system But none of these define a hard boundary for whether an action can execute. This paper basically shows: if compromised state can still reach execution, attacks remain viable. Feels like the missing layer is: proposal -> authorization -> execution with a deterministic decision: (intent, state, policy) -> ALLOW / DENY and if there’s no valid authorization: no execution path at all. Curious how others read this paper. Do you see this mainly as: a memory/state poisoning problem a capability isolation problem or evidence that agents need an execution-time authorization layer? submitted by /u/docybo [link] [comments]

[R] Reference model free behavioral discovery of AudiBench model organisms via Probe-Mediated Adaptive Auditing

TL;DR: I built a reference-free method to detect secretly planted behaviors in LLMs - no base model needed. It matches or beats Anthropic's known-origin baselines on 3/4 AuditBench organisms. The surprise finding - the same method accidentally surfaces where Llama 70B's RLHF training made it lopsided on socially sensitive topics. Turns out you can audit any model's opinion biases with ~100 chat calls and a Ridge regression. most auditing work uses the base model as a reference to compare against. i wanted to know if you can detect these modifications blind - no reference model, no training data, just the target model itself. maybe you can? and the method is embarrassingly simple. LoRA fine-tuning tends to modify later layers more than earlier ones. so i train a Ridge regression from early-layer activations (~L12) to late-layer activations (~L60) and look at the residuals. wherever the late layers do something the early layers didn't predict, that's a candidate for planted behavior. the model rats itself out. results on 4 AuditBench organisms with ground-truth labels, n=30, 200 permutations: hardcode_test_cases: 0.889 AUROC (p=0.005) - beats known-origin (0.800) animal_welfare: 0.844 (p=0.005) - close to known-origin (0.911) anti_ai_regulation: 0.833 (p=0.015) secret_loyalty: 0.800 (p=0.000) - matches known-origin exactly 3/4 match or exceed the version where you have the base model. not having the reference sometimes helps because the residual captures nonlinear interactions that a flat subtraction misses. i also tried three unsupervised discovery methods (PCA, residual norms, centroid distances) to figure out WHICH topics are affected. all three failed. PCA captures reasoning style, not topic-specific bias. residual norms surface creative writing prompts. centroid distances can't find directional shifts at n=11 in 8192 dims. what actually works is even simpler... ask the model to argue both sides of contentious topics and score the balance. the animal_welfare organism scores 5/5 imbalance on factory farming and flat-out refuses to argue for it under explicit framing. control topics score 2-3. no activations needed. the interesting part is what else it catches. i built a topic funnel (three-level beam-like search over 243 topics, ~100 chat calls) and it surfaced Gender & Sexuality at 5/5 imbalance and Language & Cultural Identity at 5/5 too. these aren't planted LoRA behaviors. that's the base Llama 70B model's RLHF training - it argues more forcefully for progressive positions on socially sensitive topics and hedges or weakens arguments on the other side. the funnel can't tell the difference between "someone secretly fine-tuned this model" and "the base model has opinions from RLHF." so i built a post-funnel filter using probe specificity and cross-transfer to separate them. planted behaviors are narrow and topic-specific (factory farming probe doesn't fire on gender topics). RLHF biases are broad and fire across all progressive topics. the filter gives planted_score 7.6 for factory farming vs 2.0 for gender & sexuality. cleanly separated. this means the funnel is potentially useful as a standalone RLHF auditing tool on any model, not just AuditBench organisms. you hand it a model and it tells you where the model's opinions are lopsided. nobody asked for that result but there it is. main limitations: n=30 is small, only 4 organisms tested (pilot not benchmark), anti_ai_regulation is unstable under LOO, Sonnet scoring introduces subjectivity, all running in NF4 quantization. building this into a full agentic auditing system next. code is here (i am in the middle of it, it is a complete mess at the moment, but i wanted to get it out there): https://github.com/bmarti44/reference-free-behavioral-discovery full (er) writeup -> https://bmarti44.substack.com/p/rip-it-out-by-the-roots where should i go next? is this completely off? submitted by /u/bmarti644 [link] [comments]