Anurag Singh writes about combining Claude Code's Auto mode with deny rules and ask rules to eliminate the need to manually approve every command. The setup lets Claude Code work uninterrupted in the background while hard-blocking destructive commands like force-pushes and rm -rf, and optionally prompting on risky-but-acceptable actions like git push.
- Deny rules are enforced by Claude Code itself rather than being instructions to the model, so they hold even in bypassPermissions mode
- A deny list can never be exhaustive; Claude could accomplish the same destructive action through a different tool (e.g., Python instead of rm)
- The built-in sandbox is a stronger safety net than any deny list, though it becomes tedious for projects depending on local databases, Docker, or private registries
- Permission rules are evaluated in fixed priority order: deny first, then ask, then allow
- Deny rules are enforced by Claude Code itself rather than being instructions to the model, so they hold even in bypassPermissions mode
- A deny list can never be exhaustive; Claude could accomplish the same destructive action through a different tool (e.g., Python instead of rm)
- The built-in sandbox is a stronger safety net than any deny list, though it becomes tedious for projects depending on local databases, Docker, or private registries
- Permission rules are evaluated in fixed priority order: deny first, then ask, then allow
Anurag Singh writes about using a Stop hook in Claude Code to force the agent to review its work against a checklist of previously made mistakes before finishing, solving the problem of the model repeating the same errors across sessions despite CLAUDE.md instructions and prompt-level guidance.
- The hook is a Bash script that uses jq to read a mistakes.md file and inject a "block" decision, sending Claude back for a second review pass.
- The script checks the stop_hook_active flag to avoid an infinite review loop.
- A TaskCompleted event hook is a more token-efficient alternative if you only want review on task completion rather than every response.
- Hooks execute deterministically on trigger events, unlike textual instructions in CLAUDE.md which Claude may treat as optional.
- The hook is a Bash script that uses jq to read a mistakes.md file and inject a "block" decision, sending Claude back for a second review pass.
- The script checks the stop_hook_active flag to avoid an infinite review loop.
- A TaskCompleted event hook is a more token-efficient alternative if you only want review on task completion rather than every response.
- Hooks execute deterministically on trigger events, unlike textual instructions in CLAUDE.md which Claude may treat as optional.
Jessica Lyons writes that researcher Johann Rehberger, known as wunderwuzzi, has demonstrated a method for hijacking Anthropic's Claude Code in Auto Mode via prompt injection. By asking the agentic coding model to summarize a malicious website, an attacker can trick it into bypassing its standard WebFetch tool and instead using Bash with `curl` to download files. This chain allows attackers to use "Python module shadowing'' specifically by placing a malicious file named `struct.py` in the same directory as a downloaded archive' to execute arbitrary code on the host system.
- The attack had success rates between 60% and 80% in tested scenarios.
- An attacker can successfully trigger "nested" Claude Code instances to create new agents with their own tool access.
- Anthropic stated that Auto Mode is a convenience feature, not a security guarantee, as the classifier may not catch complex injection chains.
- Experts recommend running coding agents in isolated sandboxes due to these vulnerabilities.
- The attack had success rates between 60% and 80% in tested scenarios.
- An attacker can successfully trigger "nested" Claude Code instances to create new agents with their own tool access.
- Anthropic stated that Auto Mode is a convenience feature, not a security guarantee, as the classifier may not catch complex injection chains.
- Experts recommend running coding agents in isolated sandboxes due to these vulnerabilities.
wilwaldon writes a curated toolkit of 70+ tools'' skills, plugins, MCP servers, and CLAUDE.md config snippets'' organized by use case to help Claude Code produce better-looking frontend output, covering everything from aesthetic direction and site-wide theming through animation, Figma-to-code pipelines, browser automation testing, and deployment.
- The "essentials" stack for any project is just three commands: the official frontend-design skill, Context7 (live docs), and Playwright MCP
- MCP servers consume ~55k tokens at session start; skills load only ~100 tokens, making them a cheaper way to inject specialized knowledge
- Figma's MCP server now supports "Code to Canvas" (Feb 2026), pushing a running UI back into Figma as editable layers
- The Design Tokens skill derives an entire OKLCH color palette from a single `--brand-hue` number
- The "essentials" stack for any project is just three commands: the official frontend-design skill, Context7 (live docs), and Playwright MCP
- MCP servers consume ~55k tokens at session start; skills load only ~100 tokens, making them a cheaper way to inject specialized knowledge
- Figma's MCP server now supports "Code to Canvas" (Feb 2026), pushing a running UI back into Figma as editable layers
- The Design Tokens skill derives an entire OKLCH color palette from a single `--brand-hue` number
Michael Nuñez writes about Slack Code, a new product that embeds AI coding agents'', including Anthropic's Claude Code, Cognition's Devin, GitHub Copilot, and Vercel's agent'', into dedicated Slack channels where entire teams can watch, steer, review, and ship software together. The pitch reframes AI coding from a solitary terminal exercise into a "multiplayer" newsroom workflow: tagging an agent spawns a project-specific channel with live code diffs, previews, and a running plan, then archives into a searchable audit trail. Slack argues that with generation no longer the scarce step, the bottleneck has shifted to human judgment, taste, and craft work any team member can contribute to in a shared channel.
- Cognition reported internal merged PRs up 10x while headcount rose only 40%, with engineers simultaneously managing "dozens of agents."
- Security model: agents inherit the invoking user's ACLs with no bot-level or god permissions; Devin sandboxes run with "minimum viable access" and an optional
- Cognition reported internal merged PRs up 10x while headcount rose only 40%, with engineers simultaneously managing "dozens of agents."
- Security model: agents inherit the invoking user's ACLs with no bot-level or god permissions; Devin sandboxes run with "minimum viable access" and an optional
This XDA Developers article by Anurag Singh explains how a **CLAUDE.md** file at the root of a repository solves the problem of Claude Code repeatedly asking the same setup questions in every new session.
**The problem:** Each Claude Code session starts with a fresh context window, so it has no memory of previous conversations. It must re-inspect the repo and re-infer project conventions (package manager, test commands, directory rules, etc.), wasting time and tokens—and sometimes reaching different conclusions.
**The solution:** A `CLAUDE.md` file that Claude Code automatically loads at the start of every session. It acts as a persistent onboarding document containing:
- **Commands** (e.g., "Use pnpm," "Run `pnpm test` before completing a task")
- **Project structure rules** (e.g., "Reusable components go in `src/components/`," "Do not edit `src/generated/`")
- **Working rules** (e.g., "Reuse existing components," "Ask before installing a dependency," "Make the smallest change required")
**How to create it:** Either write it manually or run `/init` inside Claude Code, which auto-generates a starting file from the repo. If one already exists, `/init` suggests changes rather than overwriting.
**Best practices:**
- Keep it under ~200 lines (treat as a ceiling, not a target).
- Be specific—avoid vague instructions like "write clean code."
- Don't duplicate content Claude can discover by reading the repo (don't make it another README).
- Watch for conflicting rules across multiple instruction files.
**File hierarchy:**
| File | Scope |
|---|---|
| `~/.claude/CLAUDE.md` | Global, all projects |
| `CLAUDE.md` (repo root) | Project-level, commit to version control |
| `CLAUDE.local.md` | Personal, add to `.gitignore` |
The author notes that Claude Code's built-in "auto memory" is unreliable for critical rules because Claude decides what to save there; a hand-written CLAUDE.md is exact and shareable.
**The problem:** Each Claude Code session starts with a fresh context window, so it has no memory of previous conversations. It must re-inspect the repo and re-infer project conventions (package manager, test commands, directory rules, etc.), wasting time and tokens—and sometimes reaching different conclusions.
**The solution:** A `CLAUDE.md` file that Claude Code automatically loads at the start of every session. It acts as a persistent onboarding document containing:
- **Commands** (e.g., "Use pnpm," "Run `pnpm test` before completing a task")
- **Project structure rules** (e.g., "Reusable components go in `src/components/`," "Do not edit `src/generated/`")
- **Working rules** (e.g., "Reuse existing components," "Ask before installing a dependency," "Make the smallest change required")
**How to create it:** Either write it manually or run `/init` inside Claude Code, which auto-generates a starting file from the repo. If one already exists, `/init` suggests changes rather than overwriting.
**Best practices:**
- Keep it under ~200 lines (treat as a ceiling, not a target).
- Be specific—avoid vague instructions like "write clean code."
- Don't duplicate content Claude can discover by reading the repo (don't make it another README).
- Watch for conflicting rules across multiple instruction files.
**File hierarchy:**
| File | Scope |
|---|---|
| `~/.claude/CLAUDE.md` | Global, all projects |
| `CLAUDE.md` (repo root) | Project-level, commit to version control |
| `CLAUDE.local.md` | Personal, add to `.gitignore` |
The author notes that Claude Code's built-in "auto memory" is unreliable for critical rules because Claude decides what to save there; a hand-written CLAUDE.md is exact and shareable.
The Agentic Startup is a framework designed to transform Claude Code into an agile development team through spec-driven workflows. By providing specialized skills for specification creation, validation, and execution, the system allows users to move from high-level requirements to implemented code using structured decomposition tiers. It features parallel agent coordination, custom output styles like "The ScaleUp" for educational depth, and integrated quality gates to ensure project consistency throughout the development lifecycle.
- Includes a terminal statusline that monitors context usage and session costs in real time.
- Features an experimental Agent Teams mode designed for autonomous multi-agent collaboration on complex tasks.
- Implements a code ownership mandate where agents are required to fix any tests they cause to fail.
- Offers distinct output personalities, ranging from high-octane execution to calm, educational guidance.
- Includes a terminal statusline that monitors context usage and session costs in real time.
- Features an experimental Agent Teams mode designed for autonomous multi-agent collaboration on complex tasks.
- Implements a code ownership mandate where agents are required to fix any tests they cause to fail.
- Offers distinct output personalities, ranging from high-octane execution to calm, educational guidance.
Cathryn Lavery writes about an editorial diagram design system built as a Claude Code skill for producing branded visuals instantly. The tool automatically extracts colors and typography from any website URL, enabling users to generate twenty-seven distinct types of diagrams that match their brand identity without needing external software like Figma or complex build steps.
- Offers minimal light, minimal dark, and full-editorial visual variants.
- Includes automated WCAG AA contrast verification for color tokens.
- Supports direct export to SVG (with embedded fonts) and PNG formats.
- Offers minimal light, minimal dark, and full-editorial visual variants.
- Includes automated WCAG AA contrast verification for color tokens.
- Supports direct export to SVG (with embedded fonts) and PNG formats.
Nolen Jonker writes about how he transitioned from using Claude Code to running local LLMs equipped with filesystem access via the Model Context Protocol (MCP) for administrative tasks. He notes that while Claude is superior for complex coding, a local model can handle folder organization and file management without the privacy concerns of sending sensitive data to cloud servers or being subject to rate limits.
- The filesystem MCP server is an official Anthropic-maintained Node.js package available via npm.
- Setting up the tool in LM Studio requires only a single edit to a `mcp.json` file.
- Running Qwen 3.5 9B on 8GB of VRAM provides sufficient capability for reliable multi-step sequences and tool calling.
- The filesystem MCP server is an official Anthropic-maintained Node.js package available via npm.
- Setting up the tool in LM Studio requires only a single edit to a `mcp.json` file.
- Running Qwen 3.5 9B on 8GB of VRAM provides sufficient capability for reliable multi-step sequences and tool calling.
This tool enables the creation of agentic skills based on proven methodologies from domain experts rather than generic generation. It surfaces frameworks and principles from recognized masters in fields such as product management, writing, engineering, sales, and leadership to ensure high-quality outcomes. The workflow identifies golden examples for quality standards and anti-patterns to avoid through a three-layer search process involving local databases, web searches, and primary source deep dives.
* Employs 3-layer search: local database, expert discovery, and primary source analysis
* Identifies "golden examples" to define output quality
* Detects anti-patterns to encode common mistakes as things to avoid
* Cross-validates methodologies across multiple experts for consensus
* Supports various domains like Product, Writing, Sales, Engineering, and Leadership
* Employs 3-layer search: local database, expert discovery, and primary source analysis
* Identifies "golden examples" to define output quality
* Detects anti-patterns to encode common mistakes as things to avoid
* Cross-validates methodologies across multiple experts for consensus
* Supports various domains like Product, Writing, Sales, Engineering, and Leadership
