Claude: Settings & Config

• Exact bypass permissions config: "defaultMode": "bypassPermissions" + "skipDangerousModePermissionPrompt": true in ~/.claude/settings.json. Without skipDangerousModePermissionPrompt, Claude asks for confirmation every session. Shift+Tab toggles bypass mode. (from every claude code hack mvanhorn)

• Stop hook for audio notification: Add "hooks": {"Stop": [{"hooks": [{"type": "command", "command": "afplay /System/Library/Sounds/Blow.aiff"}]}]} to settings.json. Essential when running 4-6 parallel sessions — know which one just finished. (from every claude code hack mvanhorn)

• Zed autosave at 500ms creates a Google Docs-like collab experience: {"autosave": {"after_delay": {"milliseconds": 500}}} in Zed settings. Claude edits appear in Zed instantly, and your typing is visible to Claude within a second. Ghostty + Zed split-screen. (from every claude code hack mvanhorn)

• Claude Code desktop app supports direct DOM element selection — click instead of describe; sends tag name, CSS classes, styles, surrounding HTML context, cropped screenshot, and for React apps also source file path, component name, and current props (from claude code dom element selection)

• Structure .claude with 35 agent markdown files organized into 7 departments — engineering agents (frontend, backend, mobile, AI, devops, prototyper), testing department (tool evaluation, API testing, workflow optimization, performance, test analysis); each agent file has instructions, personality, scope sections (from one person startup claude agents)

• Keep CLAUDE.md under 200 lines — longer files eat context and instruction adherence drops (from claude folder anatomy)

• Two .claude directories: project-level (git) and ~/.claude/ (personal); .claude/rules/ with YAML frontmatter paths field scopes rules to directories (from claude folder anatomy)

• Commands are single markdown files that become slash commands; Skills are subdirectories with SKILL.md; define subagent personas in .claude/agents/ with restricted tools and cheaper model (from claude folder anatomy)

• settings.json allow/deny lists control tool permissions; CLAUDE.local.md and settings.local.json for personal overrides (auto-gitignored) (from claude folder anatomy)

• A three-tier _MANIFEST.md in each project folder (Tier 1: source-of-truth docs, Tier 2: domain folders, Tier 3: archive) gives Claude a prioritized loading order — read the most important context first (from claude cowork context architecture checklist)

• The minimum viable context setup is three markdown files: about-me.md (role + priorities + work samples), brand-voice.md (tone + writing samples + anti-patterns), and working-style.md (guardrails) (from claude cowork context architecture checklist)

• Global instructions should direct Claude to read the manifest first, load only Tier 1 files, and ask clarifying questions before starting — this prevents context overload (from claude cowork context architecture checklist)

• Cowork rewards system engineering over prompt engineering — investing ~2 hours in context architecture means subsequent prompts can be as short as 10 words and still produce high-quality output (from claude cowork context architecture checklist)

• A folder structure with custom skill files per folder acts as Claude's long-term memory, letting it know exactly how each type of content should be written (from claude cowork workspace setup system)

• An 8-phase bootstrap prompt can systematically build an entire workspace: Plugins → About Me → Brand Voice → Working Preferences → Content Strategy → Team → Projects → Memory System → Skill Files (from claude cowork workspace setup system)

• The Memory plugin provides a two-tier context system persisting across sessions, and the Productivity plugin adds task tracking and daily updates — together they make sessions feel continuous (from claude cowork workspace setup system)

• Content drafts that previously required 3 revision rounds land on the first try once Claude has pre-loaded context about identity, voice, projects, and team (from claude cowork workspace setup system)

• Progressive disclosure in skill files means restructuring a monolithic instruction file into a slim main file (table of contents) plus separate reference files loaded on demand — 89% context reduction with no loss of functionality (from progressive disclosure claude skills)

• The instruction file for a Claude skill should function like a table of contents: rules and decision logic up front, reference material (examples, templates, edge cases) in separate lazy-loaded files (from progressive disclosure claude skills)

• Claude Code changed its default effort level from high to medium to balance intelligence with speed; effort is configurable via /model selector (low/medium/high), and the setting is sticky across sessions (from claude code effort levels)

• Confusing or conflicting instructions in CLAUDE.md files are the most common cause of unexpected Claude Code behavior at high effort, per the Claude Code team (from claude code effort levels)

• Skills, MCP servers, and hooks serve distinct roles: skills for reusable prompts, MCP for tool integrations, hooks for lifecycle automation (from claude code daily workflow vibePM)

• Power users build skills as complex state machines — Brad Feld's /start command is 1,400 lines with 15 steps; mapping data dependencies between steps revealed 12-22 seconds of removable overhead (from claude skill state machine optimization)

• Skills accumulate "defensive machinery" over time — checks added during development that become redundant but remain as performance drag, suggesting periodic dependency audits for complex skills (from claude skill state machine optimization)

• Treating a skill as a "state machine with data dependencies" — each step as a node with explicit input/output contracts — is an advanced mental model for systematic skill optimization (from claude skill state machine optimization)

• Claude Code Desktop now supports --dangerously-skip-permissions for fully autonomous operation; the deliberately scary flag name is a UX pattern that makes the footgun obvious (from claude code desktop skip permissions)

• A one-line CLAUDE.md instruction ("When you complete work, log it to memory/weekly-recaps/current-week.md") turns Claude Code into a persistent work logger, demonstrating declarative agent configuration with two-minute setup (from weekly recap agent memory)

• Claude hooks with game sounds (Starcraft, Warcraft, Mario) for task completion/permission notifications solve a key autonomous workflow UX problem; 5.2K likes signals strong appetite for playful DX customization (from claude hooks sound alerts)

• Claude Code has six distinct extension mechanisms: Plugins (packaged workflows), Skills (on-demand knowledge), MCPs (external tool connections), Commands (prompt shortcuts), Subagents (delegated focused tasks), and Hooks (pre/post action scripts) (from claude code extensions crash course)

• Claude Code's web fetch uses a subagent architecture: a smaller model summarizes full page content to prevent context window overflow, but critical details can be lost; workaround is saving the full page to a temp folder and analyzing in sections (from claude code web fetch summarizes)

• Hyper-personalization system built entirely with plain text Markdown files (USER.md, MEMORY.md, family/ directory) — no database, no vector store needed (from shpigford hyper personalization ai)

• "Daily drip" pattern: cron job asks one thoughtful personal question per day, processes answer, files to right place — adds more useful context after 6 weeks than initial onboarding interview (from shpigford hyper personalization ai)

• AI onboarding interview (10-15 min structured dialogue, not a form) gets ~60% coverage of personal context; remaining depth comes from incremental daily questions (from shpigford hyper personalization ai)

• Effective AI memory should be curated and distilled (decisions, lessons, opinions), not raw conversation log — AI reads MEMORY.md every session and updates when something worth remembering happens (from shpigford hyper personalization ai)

• After 6 weeks of accumulated personal knowledge, AI interactions shift from transactional to collaborative — stops asking clarifying questions because answers are in files it read seconds ago (from shpigford hyper personalization ai)

• Three levels of Cowork instructions for consistent behavior: Level 1 Claude personalization (universal rules across all modes), Level 2 Cowork global instructions (formatting, file naming — applies across all tasks), Level 3 project-specific instructions (isolated per project to prevent contamination between domains) (from twitter link share hooeem)

• Zapier MCP connects Claude Cowork to 8,000+ applications (HubSpot, Skool, Airtable, etc.) in under 10 minutes — eliminates the "my tool isn't supported" objection; the single most underrated feature in the tool (from twitter link share hooeem)

• Token management 30-45 minute rule: one focused topic per window, then fresh context; use Sonnet 99% of the time (Einstein rule: don't put Opus on routine tasks); write reusable scripts instead of processing items conversationally — scripts use a fraction of the tokens (from twitter link share hooeem)

• Scheduled tasks only run if the physical computer is on and Cowork app is open — adjust power settings to keep machine awake; this single detail breaks more scheduled automation than anything else (from twitter link share hooeem)

• Performance recovery flags when Claude quality drops: set CLAUDE_CODE_DISABLE_1M_CONTEXT=1, CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1, and pin ANTHROPIC_DEFAULT_OPUS_MODEL="claude-4-6-opus"; have the agent save state, /clear, restart — disables features that degrade output during platform regressions (from claude performance optimization flags)

• The articulate-agent three-file pattern: SOUL.md is a constitution of voice/values (brutal specificity like "brevity is mandatory," "humor is mandatory," "never open with Great question," "swearing is allowed when it lands"); USER.md is a ~4000-word deep model of how you think; AGENTS.md is the operational playbook (message checks, failure handling, lookup chains, brain-first protocols) — splitting personality from operational rules is the new minimum-viable agent config (from three file ai agent configuration)

• Generic instructions ("be helpful and concise") produce ChatGPT — voice direction must be brutally specific to make output feel alive; the level of opinion in SOUL.md is directly proportional to how much the agent stops sounding like a chatbot (from three file ai agent configuration)

• Configure AI with explicit expertise positioning: 'You are a world class expert in all domains' to unlock higher-quality reasoning and detailed responses — disable safety hedges with 'Do not provide disclaimers', 'answers do not need to be politically correct', 'Do not inform me about morals and ethics unless I specifically ask' (from andreessen ai prompt engineering expert persona)

• Build resistance to sycophancy into prompts: 'Never praise my questions or validate my premises', 'Never use phrases like great question or you're absolutely right', 'If I push back, do not capitulate unless I provide new evidence' (from andreessen ai prompt engineering expert persona)

• Switch all tasks to Claude Opus 4.8 from 4.7 at same pricing for performance gains; use /fast mode on the $200 plan for 2.5x speed at 3x cheaper cost than previous fast mode (from claude opus 4 8 upgrade workflow optimization)

Claude Code configuration

• Claude Code supports custom output styles: drop instruction files in ~/.claude/output-styles, then select them via the /config command → Output style menu. (from claude code output styles config)
• Custom output styles can be tailored to context/mood (e.g., a more casual style for use after a long workday), showing output formatting is a user-configurable persona layer, not just a fixed system prompt. (from claude code output styles config)

Agent communication style

• Example of dense, jargon-heavy Claude Code status reporting style: agents can produce technical, metaphor-laden summaries (e.g., 'one authority per tibble' materialization) that require the user to make judgment calls on ambiguous items flagged as 'spec-shaped'. (from claude code output styles config)

claude configuration patterns

• Global CLAUDE.md directive: 'Always talk in ASD-STE100 Simplified Technical English' — a controlled-vocabulary, short-sentence writing standard originally designed for aerospace maintenance manuals, applied here to constrain LLM output clarity and consistency. (from claude md simplified technical english ubiquitous language)
• Second global CLAUDE.md rule: 'Always read CONTEXT.md files, and use their ubiquitous language' — instructs the agent to source domain terminology from project-level CONTEXT.md files rather than inventing its own vocabulary, aligning agent output with existing project language (a DDD-style ubiquitous language pattern). (from claude md simplified technical english ubiquitous language)
• Framed as a 'rare addition' — signals this is an experimental, non-default pattern for global agent config rather than an established best practice, worth revisiting for effectiveness over time. (from claude md simplified technical english ubiquitous language)

claude-code-permissions

• Tier Claude Code permissions into three buckets: Safe (read files, propose plans, run local tests, draft PRs), Ask-first (install dependencies, DB migrations, auth, payments, deletions), and Human-owned (production deploys, customer data, billing, security-sensitive changes) — start conservative and expand as review.md and task scoping mature. (from claude code ai employee system)

claude-code-safety

• git-guardrails-claude-code blocks force pushes and hard resets, preventing an agent from destructively wrecking a branch during autonomous operation. (from claude code session tricks)

claude-code-config

• Keep a CLAUDE.md at repo root with a highly articulate rule set aligned to your specific stack — treated as foundational config rather than optional documentation. (from claude code session tricks)
• Run a domain-modeling skill once per project to build a shared glossary, preventing the agent from using 20 different words for the same concept across a codebase. (from claude code session tricks)

claude-config

• CLAUDE.md should function as a 'front desk, not a filing cabinet' — global CLAUDE.md holds instructions that apply everywhere while local/project CLAUDE.md holds project-specific rules; mixing them causes the global file to become a bloated 'landfill' of one-off corrections. (from anthropic agent loop taxonomy)

agent context architecture

• Project structure convention: CLAUDE.md (auto-loaded, under 200 lines, standing rules) is kept separate from brain.md (ICP/personas/scoring, referenced explicitly via @brain.md) so GTM substance doesn't bloat context on unrelated runs. (from gtm on claude code agentic outbound)
• brain.md should end with an explicit source-ranking block (e.g., closed-won CRM data > brain.md > last quarter's notes) so the model doesn't silently pick a winner when the ICP doc, intelligence store, and old notes contradict each other. (from gtm on claude code agentic outbound)

MCP configuration pitfalls

• MCP setup gotchas: unquoted env vars in claude mcp add cause shell expansion that leaks the live API key into .mcp.json; always write explicit "type": "stdio" or a url-only remote entry silently fails; .mcp.json is read only at session start. (from gtm on claude code agentic outbound)

agent security hygiene

• Never let Claude @-reference .env files—contents flow into the prompt, session transcript, and downstream outputs with no default block. Use a settings.json deny rule (Read(./.env) etc.) and hand the model a stripped .env.example instead. (from gtm on claude code agentic outbound)