Best Practices for Using Claude Code

Most developers use Claude Code like a chatbot. They type "build me an API" and wonder why the output is garbage. The developers shipping real features with it treat every session like a briefing. Here's what a productive Claude Code session actually looks like: 𝟭. 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 This is your project's DNA. Architecture decisions, naming conventions, what NOT to do. Claude reads this file automatically before every task. If you're not using it, you're letting Claude guess your standards. It will guess wrong. 𝟮. 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 Don't let Claude read your entire codebase. Feed it the specific files that matter: the endpoint you're extending, the test that's failing, the AppHost configuration. Focused context produces focused output. 𝟯. 𝗧𝗮𝘀𝗸 "Add a feature" is a terrible prompt. "Add a DELETE /orders/{id}/cancel endpoint with an integration test, following the patterns in OrderEndpoints.cs" is a great one. Specificity is the difference between useful code and code you'll delete. 𝟰. 𝗖𝗼𝗻𝘀𝘁𝗿𝗮𝗶𝗻𝘁𝘀 This is where most people fail. Without guardrails, Claude will "help" by refactoring files you didn't ask it to touch, adding packages you don't want, and restructuring code that was fine. Tell it what NOT to do. Explicitly. 𝟱. 𝗩𝗲𝗿𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 Make Claude prove the code works before it says it's done. "Run dotnet build. Run dotnet test. If anything fails, fix it." This one rule eliminates 80% of the back-and-forth. The pattern is simple: rules, context, task, guardrails, verification. Every time. The developers getting 10x value from AI coding tools aren't smarter. They're just more structured. I put together a free visual guide with 32 illustrated concepts on agentic development, including how to structure sessions like this one. Get it here 👇 https://lnkd.in/gUAUSqur

Most people install Claude Code, type a vague prompt, get a messy result, and decide it's overhyped. Meanwhile, the people getting serious value from it followed a specific sequence their first time. It took them about an hour to feel dangerous, so I mapped that sequence out. First five minutes: install it, launch it in your project directory. But here's where most people go wrong. They skip running /init. That command generates a CLAUDE.md file, and it's the entire difference between Claude Code being a generic chatbot and being useful for YOUR work specifically. Project conventions, build commands, architectural decisions, all persisted across every session. Without it, you're starting from zero every time. Next ten minutes: learn the built-in tools. Read, Edit, Grep, Glob, Bash. Claude Code has dedicated tools for file operations that are faster and more reliable than shell commands. Most beginners never realize this because they treat it like ChatGPT instead of an agent with a real toolkit. Then learn Plan Mode. This one saves you from the most common failure: Claude confidently building the wrong thing. /plan reads your files without touching anything, maps the codebase, and tells you what it intends to do before it does it. Ten minutes here saves hours of undoing bad code. The back half is where it gets spicy. Skills let you build a workflow once and run it with a slash command forever. Hooks auto-lint or block destructive commands. MCP servers connect to Notion, GitHub, Slack, your database. Claude Code stops being a coding assistant and starts being an automation layer. Full 60-minute path is in the infographic below (be sure to save it). 👇

Claude 4.7 Opus has a 1 Million token context window. Yet most engineers are spending these tokens like loose change in their pocket. Here are 3 simple claude code best practices for efficient token usage: [1] The principle of least context Just because the window is 1M tokens doesn't mean you should use them all at once. I've found that the most accurate refactors happen when the context is tight and focused. 1). Only include files that are directly in the call stack of the feature. 2). Use stubs or interfaces for external services instead of the full implementation. 3). Keep your core logic and "rules" at the very bottom of the prompt. When the model doesn't have to sift through 500kb of boilerplate, its ability to find edge cases in your business logic goes up significantly. [2] Manage your architectural boundaries Dumping a whole repo makes the AI think everything is equally important. You need to act as a filter. If you're working on a database migration, Claude doesn't need to see your CSS-in-JS files. 1). Create a map of the 5-10 most relevant files for the task. 2). Explicitly tell the model which files are "Read Only" and which one it is allowed to "Edit." 3). Use XML tags like <architecture_overview> to give context without the line-by-line noise. This forces the model to reason within the boundaries you set, rather than wandering off into unrelated parts of the system. [3] Avoid the context poisoning trap LLMs are historically better at recalling information from the very beginning or the very end of a prompt. This is often called the "middle-out" problem. If your core problem is buried in 800,000 tokens of background info, the model will likely miss it. 1). Place your most critical instructions or the "Current Problem" at the very end. 2). Use a <thinking> block to ask the model to summarize the context before it writes code. 3). If the chat gets too long, start a fresh one and only carry over the "gold" code state. Every unnecessary token you add is a tax on the model's intelligence. Engineering isn't about how much information you can carry. It’s about how much noise you can ignore.

*** How the Creator of Claude Code Actually Uses It *** Boris Cherny just shared his Claude Code workflow, and it’s surprisingly practical. Key takeaways for technical leaders: 1/ Setup Philosophy He says it works great out of box with minimal customization. The tool is intentionally flexible and every team member uses it differently. 2/ Scale & Parallelization He runs 5 local Claude instances + 5-10 web sessions simultaneously. Distributes work across terminal tabs and devices (desktop + mobile), using system notifications to track progress. 3/ Model Selection Uses Opus 4.5 exclusively for coding. Despite being slower, it is a superior tool and less steering is required which makes it faster end-to-end than smaller models. 4/ Team Knowledge Management Shared CLAUDE.md file in git tracks coding standards and common mistakes. When Claude makes errors, they’re added to prevent repetition. Compounding Engineering in practice. 5/ Workflow Automation ∙ Starts with Plan mode (shift+tab twice) before executing ∙ Custom slash commands for repeated workflows (commit-push-pr, typecheck, lint) ∙ Subagents handle post-work tasks (code-simplifier, verify-app) ∙ PostToolUse hooks auto-format code to prevent CI failures 6/ Security & Permissions Pre allows safe bash commands via /permissions to eliminate friction. No skip permissions flag. 7/ Tool Integration Claude accesses Slack (MCP), BigQuery, Sentry logs, and other internal tools directly. Configuration checked into .mcp.json and shared across team. 8/ Quality Multiplier Most critical insight I got was to give Claude ways to verify its own work. Adding feedback loops (testing, validation) improves output quality 2-3x. To me his posts are somewhat counter intuitive as he talks of using more plain vanilla settings, uses the slower Opus 4.5 and uses fleet of agents not just a coding assistant. Which I guess is why I learned so much from it! https://lnkd.in/egveGqzh

Nobody mentions this when they tell you to install Claude Code. Last month I was advising one of America’s well-known banks on how to roll out Claude Code as the new standard for code production across their entire engineering organisation. Not a pilot or a proof of concept. Claude Code Enterprise to be Org-wide. The security team had one question before anything else moved forward. What can this agent actually access and do on a developer’s machine? It sounds simple but it stopped the room. Because most developers and most engineering teams have never asked it. They install the tool, they run it, they ship faster. Nobody reads the permissions. Nobody maps what the agent can reach. Nobody thinks about what happens when an AI agent with write access runs inside the same environment as production credentials, internal configs, and sensitive codebases. A bank does not have that luxury. So here is what the security team required before a single install was approved: 1. Separate local user account Claude Code runs in its own sandboxed environment. Not your main user. Not your admin account. Its own contained space with no access to the rest of your machine. 2. Codebase set to read-only The agent reads your code. It does not touch your file system. Read access only enforced at the permission level, not assumed. 3. Dedicated GitHub account for the agent Not your personal GitHub. Not a shared team account. A standalone agent account so every push, every commit, every action is logged, traceable, and attributable to the agent specifically. These are not advanced security controls. They are basic hygiene that most developers skip entirely because nobody told them to do it. If one of the largest financial institutions in America made all three mandatory before approving a single developer install,you should be asking the same questions about your own setup. It does not matter whether you are running Claude Code at a bank, a startup, or on your personal machine at home. The agent does not know the difference. It can only access what your permissions allow it to access. Lock that down before you run it again. #ai #aisecurity #claudecode

Are you using Claude to autocomplete or to think in parallel with you? Many developers treat it like a faster tab key. The real power shows up when you use it as a second brain running alongside yours. Here’s what that looks like in practice. 1. Run Work in Parallel Spin up multiple sessions and worktrees so planning, refactoring, reviewing, and debugging happen simultaneously instead of sequentially. 2. Start Complex Tasks in Plan Mode Outline architecture and approach before writing code, so execution becomes clean and intentional instead of reactive. 3. Maintain a Living CLAUDE.md Document mistakes, patterns, and guardrails so Claude improves with your workflow and reduces repeated errors over time. 4. Turn Repetition into Skills Automate recurring tasks with reusable commands and structured prompts so you build once and reuse everywhere. 5. Delegate Debugging Provide logs, failing tests, or CI output and let Claude iterate toward solutions while you focus on higher-level thinking. 6. Challenge the Output Ask for edge cases, diff comparisons, cleaner abstractions, and alternative designs to push beyond “good enough.” 7. Optimize Your Environment Set up your terminal, tabs, and context structure so you reduce friction and maximize visibility while working. 8. Use Subagents for Heavy Lifting Offload complex or exploratory tasks to parallel agents so your main context stays clean and focused. 9. Query Data Directly Use Claude to interact with databases, metrics, and analytics tools so you reason about data instead of manually extracting it. 10. Turn It Into a Learning Engine Ask for diagrams, system explanations, and critique so every project improves your mental models. The difference is simple: Autocomplete makes you faster. Parallel thinking makes you better. The question is how you’re choosing to use it.

Most developers are missing the real value of Claude Code. It is not just an AI that writes code. The actual power comes from how you configure it around your engineering workflow. After exploring it deeply, one thing became very clear to me: prompting is only a small part of the picture. What actually makes Claude Code powerful is understanding when to use what. Here’s the mental model that made it click for me: 1. CLAUDE.md Your project memory. Best for stack, architecture, coding conventions, and commands Claude should always know. 2. Skills For recurring patterns that should automatically activate when relevant. If you repeatedly say “remember to do this,” it probably belongs here. 3. Commands For workflows you intentionally trigger, like code reviews, scaffolding, debugging, or repetitive tasks. 4. Subagents Specialized assistants for focused responsibilities like security reviews, testing, or architecture discussions without polluting the main context. 5. MCP Servers The bridge to external systems. Useful for live docs, GitHub, databases, APIs, Jira, Slack, and other tools Claude normally would not access. 6. Hooks Deterministic automation. Great for formatting, validations, running tests, or preventing risky edits automatically. 7. Plugins A way to package workflows and reuse them across projects or teams. One thing I feel developers may get wrong early is trying to configure everything at once. The smarter approach is to start lean. Begin with CLAUDE.md, then commands, then skills. Add MCPs, hooks, and subagents only when friction starts appearing in your workflow. That’s when Claude stops feeling like just another coding assistant and starts feeling more like an engineering partner. Have you explored Claude Code yet? Curious what has actually improved your workflow.

𝗙𝗼𝗿 𝘁𝗵𝗲 𝗳𝗶𝗿𝘀𝘁 𝗳𝗼𝘂𝗿 𝘄𝗲𝗲𝗸𝘀 𝗼𝗳 𝘂𝘀𝗶𝗻𝗴 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗱𝗲, 𝗜 𝗵𝗮𝗱 𝗻𝗼 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 𝗳𝗶𝗹𝗲 𝗮𝘁 𝗮𝗹𝗹. I know. I know. I’d read that it was important, bookmarked three articles about it, and then never actually wrote one because I told myself I’d do it “properly” once the project was more stable. But the .claude folder is the nervous system of your agentic workflow. If it is empty, your agent is flying blind, hallucinating your build commands, and guessing your architecture (which usually ends in a broken build and a wasted token budget.) A good .claude/ setup helps solve a few common problems: → repeating the same instructions → mixing team rules with personal preferences → having no reusable setup for common tasks I am more convinced that ever: If you want Claude to actually ship production-grade code, you have to sand down the environment it operates in. 𝗧𝗵𝗲 𝗽𝗮𝗿𝘁𝘀 𝘁𝗵𝗮𝘁 𝗮𝗿𝗲 𝗺𝗼𝘀𝘁 𝘂𝘀𝗲𝗳𝘂𝗹 𝗶𝗻 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲: ⤵ 𝟭. 𝗧𝗵𝗲 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 𝗟𝗲𝗮𝗻-𝗠𝗲𝗱𝗶𝘂𝗺 Keep this under 200 lines. (If it gets too bloated, Claude starts "summarizing" your instructions mid-task.) Focus on the non-obvious stuff: your Zod validation patterns, why you use a specific logger, and your naming conventions for handlers. 𝟮. 𝗣𝗮𝘁𝗵-𝗦𝗰𝗼𝗽𝗲𝗱 𝗥𝘂𝗹𝗲𝘀 Use the .claude/rules/ folder for logic that only matters in specific places. If the agent is working in /src/api, it does not need to know your React component styling rules. This keeps the context window clean and the outputs sharp. 𝟯. 𝗣𝗿𝗲𝗧𝗼𝗼𝗹𝗨𝘀𝗲 𝗮𝘀 𝗮 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆 𝗚𝗮𝘁𝗲 You can bolt on scripts to block dangerous commands before they run. I use a simple bash firewall to stop "rm -rf" or accidental force pushes. Use exit code 2 to force the agent to stop and self-correct. (It is much cheaper than debugging a deleted database.) 𝟰. 𝗦𝗽𝗲𝗰𝗶𝗮𝗹𝗶𝘇𝗲𝗱 𝗦𝘂𝗯𝗮𝗴𝗲𝗻𝘁𝘀 I have been testing personas in .claude/agents/. A "security-auditor" agent should only have Read and Grep access. It has no business writing files. This isolation is how you scale agentic workflows without the chaos. The .claude folder is not just a config file. It is the nervous system of your local development and keeping it under 200 lines might be the most important practice to consider. Good breakdown can be found at Daily Dose of Data Science: https://lnkd.in/evEV-iap ⇣ 𝗘𝘃𝗲𝗿𝘆 𝘄𝗲𝗲𝗸, 𝗜 𝘀𝗵𝗮𝗿𝗲 𝗼𝗻𝗲 𝗱𝗲𝗲𝗽 𝗱𝗶𝘃𝗲 𝗼𝗻 𝗵𝗼𝘄 𝘁𝗼 𝗶𝗺𝗽𝗿𝗼𝘃𝗲 𝘁𝗵𝗲 𝘄𝗮𝘆 𝘆𝗼𝘂 𝘄𝗼𝗿𝗸 𝘄𝗶𝘁𝗵 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 - 𝗰𝗹𝗲𝗮𝗿, 𝗮𝗰𝘁𝗶𝗼𝗻𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗯𝘂𝗶𝗹𝘁 𝗳𝗼𝗿 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝘂𝘀𝗲 - 𝗽𝗹𝘂𝘀 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗿𝗲𝗹𝗲𝘃𝗮𝗻𝘁 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝘁𝗼 𝗵𝗲𝗹𝗽 𝘆𝗼𝘂 𝘀𝘁𝗮𝘆 𝗮𝗵𝗲𝗮𝗱: https://lnkd.in/dbf74Y9E

If your job is providing you unlimited AI access for coding, you are doing yourself a disservice by NOT going full send with agents. To be very clear, I'm not advocating for throwing AI slop into production or forcing your colleagues to review code you didn't think through. What I am saying is that you should create a low stakes scratch repo and take it to its limits. Similar to how you evaluate a new tool by pressure testing and intentionally breaking it, you need to do this with the current agents. I recently went through this exercise and this is what I learned: 1. Tools are opinionated, so learn how to structure your repo accordingly. For Claude Code you need a CLAUDE.md file and .claude/ directory to fully take advantage of the tool. 2. Similar to how you setup your dev environment for a program language, you need to do the same for your agent. You can do this by having a thoughtful CLAUDE.md file and copying key dev docs from tools you are using into .claude/docs/ as a markdown file (this is where people are using "skills"). 3. The highest leverage configuration is getting your agent to be exceptional with git and the GitHub CLI command as this allows it to quickly pull context about your project state. A CLAUDE.md file with proper software engineering principles documented (eg commit often, and pull requests can't be larger than 500 lines, each commit is a single piece of logic implemented, etc) 4. Protect your "main" branch is standard advice regardless, but it's critical when working with agents as you need to be the final review for all code entering the main branch. With that said, I let my agent create, manage, and edit everything else on GitHub. 5. Pre-commit and post-commit hook automations that self document context and updates is crucial (hence why small commits are important). But also create JSON files that document the actions taken by the agent for a specific commit, so it can use that context quickly for development decisions. 6. Writing my own context docs and prompts is a bottleneck. I instead focus on curating context and documentation, organizing created information, and constantly deleting irrelevant or merging duplicate information. The LLM can create way better prompts than me, and "planning" mode suffices. 7. Spec driven development (SDD) via GitHub's Spec-Kit framework created a major inflection point where I went from actively guiding my agent to letting it run fully on its own completing task after task with minimal input beyond "yes you can use that command in this folder"... Most of my "development" time was here refining the spec, guardrails, tests, etc. 8. Once you get to this point, a single terminal session no longer suffices. You have to start running agents in parallel to get the 10x gains, and tools are still catching up. Right now I use iTerm2 with tmux (multiple terminal tabs in a window) and give claude access to the it2 CLI to start and end terminals. ... continued below (hit char limit)

Claude Computer Use is one of Anthropic's most underrated features and it's now available in Claude Code. When it first launched, it generated massive hype. Then, silence. Not many follow-ups, and most builders moved on. Turns out Anthropic was busy making it faster, more reliable, and cheaper. Now it's inside Claude Code, meaning Claude can write your code, compile it, launch the app, click through every button, take a screenshot of the result, and report back. How I've been using it lately: (1) Native app validation - Claude builds a macOS menu bar app, launches it, and verifies every control works before you ever open it. (2) Visual bug reproduction - tell Claude "the modal clips on small windows" and it resizes, screenshots the broken state, patches the CSS, and confirms the fix. (3) GUI-only tools - interact with design tools, hardware panels, or the iOS Simulator without writing a single test harness. Claude doesn't default to screen control. It tries MCP servers first, then Bash, then browser automation, and only falls back to using the computer when nothing else can complete the task. That's exactly the power of Claude Code (and why I think we already got our generalist model). Enable this by entering /mcp in Claude Code and turning on computer-use. More here https://lnkd.in/g2NnGqVf