CLAUDE.md and repository memory
Using concise root, nested, and scoped instruction files to encode project context, conventions, past corrections, architecture, and operating rules.
52%
Best tweets about Claude Code
50 Best Tweets About Claude Code (2026)
Read the best tweets about Claude Code, covering terminal workflows, agents, hooks, skills, debugging, and real software projects. Updated weekly.
Concrete Claude Code workflows, configuration, production use, and lessons from developers shipping real changes.
- Creators
- 41
- Updated
Original Xholic analysis
What 50 top Claude Code posts reveal
The evidence set emphasizes repository instructions, reusable configuration, parallel work, and plan-and-verify workflows. It also includes practical discussion of context limits, token use, and the need for review and engineering judgment.
- Dominant tone
- Positive
- Median score
- 40.7
- Leading format
- Tutorial
- Recent posts
- 26%
80% of posts
All-time engagement
50% of posts
Published in 90 days
Conversation map
The themes creators return to
Subagents, agent teams, and parallel work
Using independent agents, teams, worktrees, specialized roles, task coordination, and parallel sessions for exploration, reviews, debugging, and feature delivery.
46%
Skills, hooks, rules, commands, and plugins
Configuring Claude Code as a reusable engineering system with skills, slash commands, path-scoped rules, deterministic hooks, permissions, and shareable plugins.
44%
Planning, implementation, and verification loops
Plan-first workflows, approval gates, TDD, tests, browser/computer checks, code review, commits, rollback, and feedback loops that let Claude validate its work.
34%
MCP, CLI, external tools, and automation
Connecting Claude Code to GitHub, databases, browsers, communication platforms, internal systems, CI/CD, and command-line tools to execute end-to-end work.
28%
Context, token, and cost management
Keeping context effective through compact instructions, clearing and compaction, context visibility, selective tools, session limits, usage analysis, and generated codebase indexes.
22%
Production workflows and team adoption
Applying Claude Code in real repositories and organizations through shared configuration, internal infrastructure, onboarding, PR workflows, enterprise-scale codebase practices, and autonomous delivery.
10%
Remote and cross-device Claude Code sessions
Controlling active Claude Code sessions from phones and collaboration apps such as Telegram, Discord, and Lark/Feishu.
6%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 65
- Median reposts
- 8
- Median replies
- 10
- Median views
- 4.4K
Posts with media make up 80% of this collection. Their median all-time score is 46.2, compared with 14.2 for text-only posts.
Format mix
- Tutorial 50% · score 27.7
- Announcement 26% · score 64.6
- List 16% · score 54.8
- Case Study 4% · score 71.7
Consensus and debate
Where creators agree, and where they do not
Shared view
Repository memory is a common setup pattern
Posts describe CLAUDE.md as repository context for conventions, past corrections, commands, and architecture decisions. Some also recommend small, folder-level instruction files for modules with local constraints.
Shared view
Configuration can capture repeatable workflows
Posts recommend moving recurring instructions and constraints into rules, hooks, skills, commands, permissions, and path-scoped configuration rather than relying solely on ad hoc prompts.
Shared view
Explore, plan, implement, and verify
Multiple workflow posts recommend understanding the codebase before editing, reviewing a plan, implementing in stages, and using tests or browser checks to inspect results.
Shared view
Parallel work is paired with specialized roles
Posts describe using subagents or agent teams for research, reviews, QA, competing debugging hypotheses, and cross-layer work. They also recommend independent tasks and, in one workflow, git worktrees for parallel sessions.
Open debate
Minimal core setup versus extensive tooling
One post argues for a root CLAUDE.md, direct CLI use, and selected MCP connections rather than wrappers and plugins. Other posts advocate a broader configuration system of skills, hooks, agents, plugins, and integrations.
Open debate
Autonomy still requires engineering judgment
One account of a principal engineer's experience reports rushed patches, ignored instructions, and substantial oversight despite planning and review practices, and argues that architecture documentation and review loops remain important.
What performs
Patterns behind standout posts
Instruction-file content appears among the highest-scoring outliers
The highest-scoring outlier, tweet 2043374229199151351, focuses on a CLAUDE.md file. The remaining listed outliers cover Claude Code channels, a shared setup, repository memory, and Claude product positioning.
Media posts had a higher median score than text posts
Deterministic analytics report a median all-time score of 46.17 for media posts, compared with 14.21 for text posts. The cited examples include setup and product/channel posts.
Tutorials are the largest format category
Tutorials account for 50% of the evidence set, ahead of announcements at 26%. Cited tutorials cover setup, configuration, skills, subagents, and workflow design.
Statistical standouts
- View standout post 1 Score 8022.9 · 196.93× median
- View standout post 2 Score 5656.3 · 138.84× median
- View standout post 3 Score 4791.7 · 117.62× median
- View standout post 4 Score 2131.3 · 52.31× median
- View standout post 5 Score 1853.6 · 45.5× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
-
1. Vaishnavi
@_vmlops
2 posts
-
2. Akshay 🚀
@akshay_pachaar
2 posts
-
3. Alpha Batcher
@alphabatcher
2 posts
-
4. Harshil Tomar
@Hartdrawss
2 posts
-
5. Sharbel
@sharbel
2 posts
-
6. Shruti Codes
@Shruti_0810
2 posts
Posts favor explicit implementation sequences
Several creators lay out ordered workflows: inspect the repository, plan before edits, verify results, retain concise repository context, and turn repeated tasks into commands or skills.
Operational examples describe concrete delivery practices
The cited posts describe specialist PR review, test and browser-based verification, phase-by-phase commits and reviews, and connections to deployment or database tools.
Context and cost management are recurring practical topics
Posts recommend checking context and usage, disabling unneeded MCP servers or skills, clearing sessions at checkpoints, and using subagents to keep exploratory work out of the main session.
Since the previous snapshot
What changed since Aug 18, 2026
- 74% of the selected posts remained.
- The creator count changed by 0.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 50-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best Claude Code tweets
Top Claude Code tweets from 41 creators
Ranked 01–50
- 01
@akshay_pachaar ·
A single 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 file just hit 15K GitHub stars. (derived from Karpathy's coding rules) Andrej Karpathy observed that LLMs make the same predictable mistakes when writing code: over-engineering, ignoring existing patterns, and adding dependencies you never asked for. If you've used AI coding assistants, you've hit all of these. But here's the thing: If the mistakes are predictable, you can prevent them with the right instructions. That's exactly what this 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 does. You drop one markdown file into your repo, and it gives Claude Code a structured set of behavioral guidelines for your entire project. This is a big deal. - Built entirely around prompt engineering for AI coding assistants - No framework, no complex tooling, just one .md file that shapes behavior Developers are moving past "use AI to write code" and into "engineer the AI's behavior so the code is actually good." The Claude Code ecosystem is growing fast, and the best tools in it aren't always software. Sometimes they're just well-crafted instructions. 100% open-source. I've shared a link to the GitHub repo in the next tweet!
- 02
@trq212 ·
We just released Claude Code channels, which allows you to control your Claude Code session through select MCPs, starting with Telegram and Discord. Use this to message Claude Code directly from your phone.
Watch video
- 03
@startupideaspod ·
Boris Cherny, the creator of Claude Code, shared his entire setup. He runs 5-10 Claudes in parallel. Half his coding happens from his phone. Here's his 3-part formula for better results: Use the smartest model available — Counterintuitive: it's actually cheaper — Smarter model = fewer tokens = lower total cost — "Once the plan is good, the code is good" Invest in your Claude MD — Plain text file. No special format. — Whole team contributes multiple times a week — Every mistake Claude makes gets added so it never happens again Give Claude a way to verify its own output — Let it run the code. Let it see the browser. — "Imagine you're a painter wearing a blindfold" — Same thing for an AI that can never check its work His morning routine: wake up, kick off 3 sessions from his phone, check in later. His workflow: start in plan mode → lock the plan → auto-accept edits → done. No fancy setup. No complex tooling. Just multiple Claudes, a good plan, and a shared knowledge base.
Watch video
- 04
- 05
@akshay_pachaar ·
Claude vs. Claude Code vs. Cowork. If you've been confused about which one to use and when, this post will clear that up in under two minutes. Anthropic now offers three distinct ways to interact with Claude, and each one targets a fundamentally different workflow. Think of it as: Chat for thinking, Code for building, and Cowork for doing. Here's a quick breakdown: 1️⃣ Claude Chat This is the conversational AI assistant most people already know. You type a prompt, Claude responds, and you iterate together. - Turn rough ideas into structured plans through conversation - Write emails, reports, essays, and long-form content - Research and summarize complex topics in minutes - Analyze documents, PDFs, and images - Build interactive prototypes through Artifacts The key here is that everything happens through conversation. You're thinking with Claude, not delegating work to it. It's available on every device, has a free tier, and supports persistent memory across sessions. The tradeoff is that it has no direct access to your local files (upload only), and it can't generate raster images natively. 2️⃣ Claude Code This is a terminal-native coding agent. You describe what you want in plain English, and Claude reads your codebase, writes code, runs tests, fixes errors, and ships the result. - Build and debug entire features across the full codebase - Write, run, and fix tests automatically - Manage git workflows and create pull requests - Spawn multiple parallel agents working on different parts of a task simultaneously It handles the full development cycle end to end, from planning to execution to testing. With the CLAUDE(.)md configuration file, you can teach it your project's conventions, patterns, and constraints so it writes code the way your team expects. The tradeoff is a steeper learning curve compared to Chat, and token costs can add up during heavy sessions. 3️⃣ Claude Cowork This is the newest addition. Anthropic describes it as Claude Code for the rest of your work. It's an agentic desktop assistant that automates file management and repetitive tasks through a GUI. You describe an outcome, and Claude plans, executes, and delivers finished work: formatted documents, organized file systems, spreadsheets with working formulas, and synthesized research. - Direct local file access and editing (no upload/download cycle) - Schedule recurring tasks automatically - Assign tasks remotely via Dispatch from your phone - Computer Use lets Claude control your screen directly It runs inside a sandboxed virtual machine on your computer, so Claude can only access folders you explicitly grant. You don't need to know how to code to use it. The tradeoff is that your computer must stay awake for tasks to run, and it's still in research preview. Here's how to think about choosing between them: → If you need to think through a problem or get writing/research help, use Chat → If you're building software and want an autonomous coding partner, use Code → If you have a clearly defined deliverable that involves local files and desktop workflows, use Cowork All three are included in the same subscription starting at $20/month, which makes it one of the highest-leverage subscriptions in productivity software right now. I've put together a visual below that maps the workflow of each product side by side. If you want to go deeper into Claude Code specifically, I wrote a detailed article covering the anatomy of the .claude/ folder, a complete guide to CLAUDE(.)md, custom commands, skills, agents, and permissions, and how to set them all up properly. Link in the next tweet.
Watch video
- 06
@aakashgupta ·
This guy literally broke down how to use Claude Code like an expert: 1:40 - Code vs Cowork vs OpenClaw 6:51 - Setting up context status line 12:03 - Sub-agents 17:49 - Creating skills 23:58 - Ask user questions tool 33:33 - Tool-powered skills: Tavily 36:57 - CLI vs MCP vs API hierarchy 39:30 - Make slides skill w/ Puppeteer 43:32 - Auto-invoking skills with hooks 46:49 - Jupyter notebooks for data trust 55:09 - The operating system file structure
Watch video
- 07
@sukh_saroy ·
Every serious Claude Code user is using this repo. if you're not, you're leaving 90% of Claude Code's power on the table. It's called claude-code-best-practice - 84 sourced tips, implementation examples for every major feature, workflow comparisons across 8 major repos, and the actual tips from Boris Cherny (creator of Claude Code) compiled in one place. Here's what's actually in it: → 84 tips organized by category -- prompting, planning, CLAUDE.md, agents, commands, skills, hooks, workflows, debugging, utilities, daily habits → best practice + implemented examples for every core concept: subagents, commands, skills, hooks, MCP servers, plugins, settings, memory, checkpointing, CLI flags → workflow comparison table -- Superpowers, BMAD-METHOD, Get Shit Done, OpenSpec, gstack, HumanLayer -- what makes each unique, how many agents/commands/skills each has → orchestration workflow -- Command → Agent → Skill pattern with a live demo → Boris Cherny tips compiled across 3 tweet threads (13 + 10 + 12 tips) and 5 podcast/video appearances → "billion dollar questions" section -- open questions about CLAUDE.md, agents vs commands vs skills, specs -- that nobody has definitively answered yet here's a few of the tips that actually change how you use it: → use subagents with "say use subagents" to throw more compute at a problem -- offload tasks to keep your main context clean → spin up a second Claude to review your plan as a staff engineer before executing → CLAUDE.md should target under 200 lines -- wrap domain-specific rules in `<important if="...">` tags so Claude doesn't ignore them as files grow → compress KV context at max 50%, not at the end -- avoid the "agent dumb zone" by doing manual /compact proactively → after a mediocre fix: "knowing everything you know now, scrap this and implement the elegant solution" was #1 trending on GitHub in March 2026. 19.7K GitHub stars. 1.7K forks. MIT license. 100% open source. (link in the comments)
Watch video
- 08
@EXM7777 ·
Claude Code by default is BLOATED: it spends a lot of tokens, argues a lot and is very slow... here's how to fix it: start from your global CLAUDE․md: 1. add this line to your : "always talk in ASD-STE100 simplified technical english and say only what needs to be said. report only the elements needed for me to make the right decisions, explained clearly" 2. keep it under 200 lines with just enough context, the longer the file the more of it gets ignored - delete it and rebuild it from scratch every 2-3 months > run /context in a fresh session, it shows what fills the window before you even type: system prompt, tools, memory files, skills... remove the biggest item, restart, check again > check /usage too, it shows which MCP server, skill, agent or plugin is burning your tokens > prefer CLIs over MCPs: a command gives back only the lines you ask for, an MCP dumps its entire result into the window every single time > turn off the MCP servers you don't use: type /mcp and toggle them off, they stay in your config for later > same for skills you rarely use, mark them manual-only (disable-model-invocation: true) so they cost nothing until you call them > write your "never do this" rules as permission settings, not sentences in CLAUDE․md because they get ignored in long sessions > use high effort only for planning, anything else should be using medium or low > /clear your session as soon as you reach a checkpoint or go above 400k context > use Claude Code for what it's best at... use headless workers for vision tasks and computer use > move heavy exploration to subagents running other harnesses, they do the reading in their own window and yours only sees the summary > put the context meter in your status line (/statusline) so you see the window filling up before quality drops > avoid the claude app, work from the terminal or an ADE like Orca (save this prompt)
- 09
@svpino ·
I asked Claude Code to summarize my talk at the Sonar Summit. Here are the 18 Claude Code tips I shared (and the complete talk below): 1. Always reference files directly using `@filename.py` or `@src/classes/` to constrain the agent. 2. CLAUDEmd → Before writing any code, describe your approach and wait for approval. Ask clarifying questions if requirements are ambiguous. 3. CLAUDEmd → If a task requires changes to more than 3 files, stop and break it into smaller tasks first. 4. Consider creating a `/decompose` command that takes a plan and outputs a list of small tasks to implement one at a time. 5. CLAUDEmd → Describe your tech stack, folder structure, coding conventions, and any anti-patterns you'd like to avoid. 6. Use `/memory` to save any personal preferences that should persist across projects. 7. Create a `.claudeignore` file containing any files the agent shouldn't read or modify. 8. CLAUDEmd → When there's a bug, start by writing a test that reproduces it, then fix it until the test passes. 9. CLAUDEmd → After writing code, list what could break and suggest tests to cover it. 10. Create a `/review-xyz` command that checks for correctness, edge cases, and consistency with codebase patterns. 11. Create a `/test` command that invokes a test sub-agent that runs your test suite. 12. CLAUDEmd → When I say something is wrong, ask clarifying questions before rewriting. 13. Use the `/rewind` command to rollback changes, then give more specific feedback and try again. 14. Use Git worktrees to run parallel agent sessions on different tasks. 15. Use `claude --dangerously-skip-permissions` on a disposable environment to iterate faster while still being able to recover when things go wrong. 16. CLAUDEmd → Every time I correct you, add a new rule to the CLAUDE .md file so it never happens again. 17. Convert any successful, repeatable prompt into a workflow by saving it as a slash command or a skill. 18. Create sub-agents for any repetitive tasks that require a large context or specialized analysis. Reuse these agents without polluting your main context.
- 10
@Hesamation ·
This is a tool I created that gives you 4-10 expert Claude Codes for different sections of your codebase (auth, DB, API) with their own memory, tasks, and skills. They can: > spawn a swarm of other Claude Codes, > talk to each other > manage parallel work Open-source for anyone interested. it's called OctoGent, a prototype I made out of curiosity about what an Agent Engineering dashboard might look like. OctoGent is simply a thin agent orchestration dashboard running locally, and it's built AROUND Claude Code, not to hide it under abstraction. with OctoGent you can have: > specialized context and skills for multiple sections of your codebase. (I call them tentacles) > a list of tasks for each tentacle, defined by you or Claude. > a CLI for Claude Code to create other Claude Codes, prompt them, and check their work. > you can control these children and see their work. > all visible in a graph canvas, so you have a God-view of what's going on. > Claude usage limits always visible so you don't get surprised. > a token heatmap of your Claude usage, like GitHub's. > a list of your past conversations with Claude Code that you can search through, or export to use elsewhere. It is pretty straightforward: spawn a new Claude Code under the database tentacle, it reads all the memories and context it wrote down, reads the to-do list, and starts working on tasks, Basically, the way you use Claude Code, just with more utilities. This is still in early stages and experimental, so if you hit any issues, submit it on the repo. You can also fork it and change it however you want. There are docs on how you can use Claude Code as a coordinator agent, how to make it use other agents, message them, how to work with its hooks, inject prompts into Claude, and use all the things it exposes. Check it out: https://t.co/95pqACH57l
Watch video
- 11
@VaibhavSisinty ·
Someone on Reddit built a single script that saves 50,000 tokens per Claude Code conversation. Every time you start a conversation, Claude Code spends 10-20 tool calls just exploring your codebase. On large projects, 30-50K tokens gone before any real work begins. The fix is called ai-codex. Run it once and it generates 5 compact markdown files: → routes.md : every API route with methods and auth tags → pages.md : full page tree with client/server flags → lib.md : all library exports with function signatures → schema.md : database schema compressed to key fields only → components.md : component index with props Add one line to your CLAUDE.md. Claude reads these first. Exploration phase gone.
- 12
@JJEnglert ·
Our engineers at @tenex_labs are slamming this new Claude Code feature. Here's how it works: @AnthropicAI just shipped Agent Teams — and it's a big deal even if you're not writing code yourself. Here's the simple version: Instead of one AI working on your problem alone, you can now spin up a whole team of AI agents that work together. One acts as the lead. The others are teammates. They each focus on a different piece of the work, talk to each other directly, and coordinate through a shared task list. Think of it like hiring a project manager who breaks the work into pieces, assigns it to specialists, and makes sure nothing falls through the cracks. Except all of those people are Claude, and they spin up in seconds. Why this matters even if you're not a developer If you've ever used Claude Code to research a problem, write a report, or automate a workflow — you've been working with one brain at a time. That brain has a limit on how much it can hold in its head before things start slipping. Agent Teams removes that bottleneck. Each teammate gets its own full memory. One can be deep in your financials while another is reviewing your competitor landscape while a third is drafting recommendations. They don't confuse each other's work because they literally can't see each other's context. And the best part — they talk to each other. The lead doesn't have to relay everything. Teammates share findings, challenge each other's conclusions, and build on each other's work directly. "Wait, didn't Claude Code already have subagents?" Yes. And this is where most people get confused. Here's the difference: Subagents are like sending an intern to go research something and come back with an answer. They do the work, hand you a summary, and they're done. They never talk to each other. You manage everything. Simple, cheap, good for focused tasks where you just need a result. Agent Teams are like assembling a working group. The teammates coordinate with each other, not just with you. They claim tasks from a shared list, message each other when they find something relevant, and the lead synthesizes everything at the end. More expensive, but the output is fundamentally different. When to use which: - Need a quick answer or a focused task done? Subagent. Fast, cheap, gets the job done. - Need multiple people looking at different angles of the same problem? Agent Team. The coordination is the point. - One person can do it without talking to anyone else? Subagent. The work benefits from debate, cross-checking, or parallel exploration? Agent Team. What our team is using it for right now: 1. Parallel code reviews — 3 teammates reviewing the same PR simultaneously. One on security, one on performance, one on test coverage. A single reviewer gravitates toward one issue type. Three specialists catch everything. 2. Competing hypotheses — 5 agents investigating the same bug, each with a different theory, actively trying to disprove each other. The theory that survives is almost always the root cause. 3. Cross-layer features — Frontend, backend, and tests each owned by a different teammate. No one steps on anyone else's work. Quick start if you want to try it: Requires Claude Code v2.1.32 or later. Add one environment variable to your settings.json: "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" Tell Claude what kind of team you want in plain English. "Create a team with 3 teammates to review this project from different angles." Claude proposes the team, you confirm, and it handles the rest — spawning teammates, assigning tasks, coordinating work. Start with 3 teammates. Keep tasks independent. Don't let two teammates touch the same files. Still experimental. But this is the first multi-agent architecture I've seen actually hold up on real dev work. Link to docs in comments below.
- 13
@_vmlops ·
14-YEAR PRINCIPAL ENGINEER... 100 HOURS IN CLAUDE CODE...20 HOURS IN CODEX.... HERE'S WHAT NOBODY TELLS YOU His stack: 80k LOC python/typescript 2800 tests, real architecture, not vibed together claude code felt like a senior dev on a deadline rushing to ship...patching instead of refactoring...spewing helper functions when the real fix was deeper...ignoring the CLAUDE.md... almost every single session 1M context window? he called it a noob trap keeps it under 25% on purpose the workflow that actually worked for him: plan mode first → 8 subagents reviewing architecture, coding standards, performance, ui design. each one grounded in reference docs he built over time postgres_performance.md python_threading.md. real guardrails then code... then commit per phase.. then code review runs again on each commit even with all that claude still moved too fast...too much babysitting codex felt different... slower...more deliberate 20 hours in, different vibe entirely the takeaway: these tools don't replace engineering judgment..they amplify it good or bad your CLAUDE.md, your architecture docs, your review loops that's the actual product...the AI is just execution
- 14
@VaibhavSisinty ·
This one file made Claude Code mass dangerous. 🤯 Andrej Karpathy posted 4 rules for how Claude Code should behave. A developer put all 4 into one file called CLAUDE. md dropped it in his project root, and his coding accuracy jumped from 65% to 94%. It hit #1 on GitHub trending overnight. Here's why it works. Claude Code has one massive flaw. Every session starts blank. It doesn't remember your stack. Doesn't remember your decisions. Doesn't know what you tried last week or why you rejected it. So it guesses. Touches files you never asked it to touch. Suggests tools that break what you already built. And you waste 20 minutes re-explaining the same context you explained yesterday. CLAUDE .md kills that problem. It's a plain text file that Claude reads the moment a session starts. Every time. No exceptions. And Karpathy says you only need 4 rules inside it: 1. Ask, don't assume : if something is unclear, ask before writing a single line. Zero silent assumptions. 2. Simplest solution first : build the simplest thing that works. No abstractions nobody asked for. 3. Don't touch unrelated code : if it's not part of the task, don't modify it. Even if you think it needs fixing. 4. Flag uncertainty : if you're not confident, say so before proceeding. Fake confidence breaks more code than honest doubt. Four rules. One file. 30 points of accuracy gained. Everyone's out here chasing the next model drop. The real ones are learning how to control the model they already have.
- 15
@InduTripat82427 ·
Most developers are using Claude Code wrong. They install it… run a few prompts… and treat it like a terminal chatbot. That’s why the results feel average. Claude Code is actually a 4-layer system 👇 1️⃣ CLAUDE.md Your project’s persistent memory. It defines: • what the system does • how the repo is structured • rules Claude should follow Think of it as the brain of the project. 2️⃣ Skills Reusable knowledge packs Claude automatically invokes. Examples: • code review rules • refactor playbooks • debugging workflows • release procedures Skills make Claude behave like a specialized engineer, not a generic model. 3️⃣ Hooks Deterministic safety gates. Important detail: Rules in CLAUDE.md → followed ~70% of the time Hooks → enforced 100% of the time Use hooks for: • running tests • formatting code • blocking risky directories 4️⃣ Agents Sub-agents with their own context windows. This lets Claude handle complex multi-step work without losing context. Most engineers miss the setup that makes all of this work. The difference between average and exceptional results is the initial configuration: • run /init on day one to generate CLAUDE.md • structure the .claude/ folder (skills, hooks, permissions) • write skill descriptions that actually trigger correctly • use memory hierarchy (global → project → subfolder) • enforce rules with hooks instead of relying on prompts When this is configured properly, the workflow becomes: Plan Mode → Auto-Accept → Iterate → Commit. If you're using Claude Code without CLAUDE.md + Skills + Hooks, you're probably using 20% of what it can actually do. #ClaudeCode #AIAgents #AIEngineering #GenAI #DeveloperTools
- 16
@techNmak ·
Someone spent months reverse-engineering every Claude Code feature into one free guide. 11K stars. 690 forks. Here's what most Claude Code users don't know exists: → /self-assessment runs directly inside Claude Code - get a personalized learning roadmap based on what you already know → /lesson-quiz [topic] after each module pinpoints exactly what you missed → Hooks trigger automatic actions before and after every Claude response - no manual intervention → Checkpoints let you rewind your entire session to any previous state → Skills teach Claude your team's architecture patterns once - it follows them forever → Subagents run specialized tasks in parallel - code review, security audits, documentation in one pipeline → Plugins bundle everything into one installable unit your whole team can use → EPUB generation built in - one script, entire guide as an offline ebook What you can build when you combine them: → Automated code review: Slash Commands + Subagents + Memory + MCP → CI/CD automation: CLI + Hooks + Background Tasks → Security audits: Subagents + Skills + Hooks in read-only mode The questions this repo answers: → When should you use a slash command vs a subagent vs a skill? → How do you wire MCP into an automated pipeline? → What does a production-ready Claude Code workflow actually look like?
- 17
@heygurisingh ·
Holy shit... someone built a TUI that shows where your Claude Code tokens actually go. Turns out 56% of my $200/day spend wasn't coding. It was Claude just... talking. It's called codeburn. Reads the session transcripts Claude Code already stores at ~/.claude/projects/ and classifies every turn into 13 categories based on tool usage patterns. No LLM calls for classification. Fully deterministic. No config. The breakdown that broke me: >> Conversation (no tools used): 56% >> Actual coding (edits + writes): 21% >> Everything else: 23% I was paying $200/day to watch Claude type paragraphs at me. ccusage shows cost per model per day. codeburn shows cost per task type, project, model, tool, and MCP server. Daily activity chart with gradient bars. Arrow keys to switch between today / week / month. SwiftBar menu bar widget if you're on Mac. One command. Works with any Claude Code install: npx codeburn
- 18
@AiwithDharmik ·
Most developers treat Claude Code like a smarter autocomplete. That's the wrong mental model. It's actually a 4-layer engineering system: 1️⃣ CLAUDE.md → persistent project memory Architecture, rules, team conventions 2️⃣ Skills → auto-invoked knowledge packs Testing patterns, code review, deploy workflows 3️⃣ Hooks → deterministic guardrails Security checks, formatting, automation 4️⃣ Agents → specialized sub-agents Break complex tasks into parallel workflows Once these are configured properly: Claude stops behaving like a chatbot. It starts behaving like a senior engineer on your team. Most people never reach this level because they skip the setup. The gap between average AI output and production-level results isn't the model. It's the infrastructure around it. Here’s the full breakdown on exactly how to build this 👇
- 19
@_vmlops ·
ANTHROPIC JUST RELEASED A GUIDE ON RUNNING CLAUDE CODE IN MILLION-LINE CODEBASES and the biggest lesson...? the model is the least important part here's what actually makes or breaks claude code at enterprise scale: ▫️ CLAUDE.md files set the foundation root file for big picture, subdirectory files for local context. keep them lean or performance tanks ▫️ hooks automate the boring stuff AND capture session learnings to improve your setup over time ▫️ skills load specialized knowledge on-demand no bloating every session with things you don't need ▫️ plugins stop good configurations from staying tribal across thousands of engineers ▫️ LSP integrations = symbol-level navigation, not grep. the difference is massive in large repos ▫️ subagents split exploration from editing so neither kills the other's context window ▫️ MCP servers connect claude to internal tools, docs, and APIs it can't otherwise reach no stale embedding index no outdated retrieval claude traverses the live codebase like a senior engineer would The org insight most teams miss: dedicate someone to claude code infra *before* the rollout.... teams that did this had developers productive from day one...teams that didn't hit frustration walls & stalled adoption also revisit your config every 3–6 months...instructions tuned for an older model can actively limit what a newer one can do this is the playbook enterprise eng teams needed full read → https://t.co/k3KdzR51bA
- 20
@sharbel ·
10 Claude Code tricks most people don't know (save this): 1. CLAUDE.md: permanent memory. Claude reads it every session. Stack, rules, naming conventions. Never explain yourself again. 2. /clear between tasks: context degrades at 90%+. Claude gets measurably dumber. New task = /clear. Every time. 3. Esc Esc: checkpoint menu. Rewind code + conversation to any point. Zero damage if Claude derails. 4. claude -w feature-branch: isolated git worktree. Claude works there, commits, PRs. Main never touched. 5. git diff main | claude -p "review": pipe anything into Claude. Logs, diffs, files. -p = non-interactive mode. 6. --effort high: 4 levels: low / medium / high / max. Default is not max. Use high on hard problems. 7. Auto memory: Claude saves its own learnings across sessions. Build commands, quirks, your preferences. Zero effort. 8. --max-budget-usd 5.00: hard spend cap per session. Pair with --max-turns 3. Essential for CI/CD. 9. .claude/rules/api.md: path-scoped rules. API rules only load for API files. Test rules for test files only. 10. claude -n "auth-refactor": name your sessions. Resume with claude -r "auth-refactor". Clean parallel workstreams. Most people use 2 of these 10.
- 21
@PawelHuryn ·
Your CLAUDE.md is doing jobs that rules, hooks, and agents were built for. Claude Code has four mechanisms to take things off your CLAUDE.md: 1. Rules fire by file path — testing rules when Claude reads test files. 2. Hooks run deterministic code on events. Not AI. 3. Skills — folders with their own instructions, tools, and constraints. 4. Agents — their own model, their own tools. Optional worktree isolation. Three scopes stack: Admin, Global, Project. Arrays combine. Settings use the most specific value. Files in subdirectories load automatically.
- 22
@techNmak ·
10 GitHub repos that actually earn their place in a Claude Code workflow : 1./ superpowers ⭐142K TDD-enforced. Deletes code written before tests exist. Forces structured thinking before any line runs. https://t.co/gUpoHVN3E6 2./ everything-claude-code ⭐147K 30 agents, 136 skills, 60 slash commands. Don't install all of it, pick 4. Still changes everything. https://t.co/UnISd5KCqX 3./ repomix ⭐23K One command packs your entire codebase into one AI-readable file. Claude sees the full picture instantly. https://t.co/1XKUO5K8xO 4./ awesome-claude-code ⭐37K The community's curated index. Only PR allowed: from Claude itself. That's the quality bar. https://t.co/ptpZVOdLgx 5./ claude-code-action ⭐7K ✅ Official Runs Claude Code directly in your CI/CD pipeline. PR reviews, automated, not demo-ware. https://t.co/HIMqZ5doIv 6./ claude-code-best-practice ⭐33K Read it, don't install it. Apply the patterns. 30 mins → weeks saved. https://t.co/93ixBVxVVg 7./ servers (GitHub MCP) ⭐83K Full GitHub access via natural language. Read repos, create issues, manage PRs. https://t.co/ddH1nK4tEa 8./ context7 ⭐52K Injects live, up-to-date library docs into your prompts. Kills hallucinated APIs dead. https://t.co/o5ujwq8hhc 9./ claude-session-restore Restores full context from previous sessions via git history. Handles files up to 2GB. https://t.co/KsWvGcjHp0 10./ awesome-claude-skills ⭐52K 50+ community skills by category. Browse before you build your own. https://t.co/mgebMQT29H
- 23
@dbreunig ·
My takeaways from scanning the Claude Code code for ~45 min this evening: 1️⃣Harness engineering is hard. There's a lot of hard won knowledge in here and plenty of diagnostics to keep the feedback flowing. 2️⃣Harnesses and prompts smooth out model quirks. @SrihariSriraman and I covered this last month, but good to see it verified here. So many conditionals based on model types and specific contexts to deploy to mitigate model weirdness. 3️⃣So much of this is CLI app boilerplate. Fully expect a tool like @badlogicgames's pi to be the foundation for any CLI agent being built today. I talk about the last point, the opportunity for shared foundations, in a post today: https://t.co/F9OFdOahYZ
- 24
@sharbel ·
How To Use Claude Code Like a CTO: 0:00 Most people use Claude Code wrong 0:52 Why the terminal scares people away 1:21 What Claude Code actually is 2:49 Using Claude Code like a CTO 4:03 Feature 1, Claude.md 5:52 Feature 2, plan mode 6:35 Feature 3, skills and slash commands 7:20 Feature 4, hooks 7:59 Feature 5, MCP servers 8:37 Feature 6, subagents 9:20 Feature 7, ultra think 10:11 Bonus, Claude Code memory 10:49 My exact Claude Code workflow 13:32 The limitations 15:46 Real example, building ViralPen 17:02 Final takeaway
Watch video
- 25
@goyalshaliniuk ·
Everyone's using Claude Code. Almost nobody understands what's happening under the hood. It feels like magic - you type, it codes, tests pass. But behind that simplicity is one of the most sophisticated agent architectures ever shipped to developers. Here's how Claude Code actually works 👇 🔹 𝗜𝗻𝗽𝘂𝘁 𝗟𝗮𝘆𝗲𝗿 User interface (CLI, IDE, CI/CD), session manager (resume, fork, persist), and a permission gate. Nothing runs without approval. 🔹 𝗞𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗟𝗮𝘆𝗲𝗿 Skill registry, task graph, context compressor, and a memory store for cross-session persistence. This is how it "remembers." 🔹 𝗧𝗵𝗲 𝗠𝗮𝘀𝘁𝗲𝗿 𝗔𝗴𝗲𝗻𝘁 𝗟𝗼𝗼𝗽 Perception → Action → Observation. The heartbeat of the entire system. 🔹 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗟𝗮𝘆𝗲𝗿 Typed tool dispatch, streaming parallel runtime, and a prompt cache that cuts cost to ~10%. 🔹 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗟𝗮𝘆𝗲𝗿 Event bus + background executor - lifecycle hooks and interception baked in. 🔹 𝗠𝘂𝗹𝘁𝗶-𝗔𝗴𝗲𝗻𝘁 𝗟𝗮𝘆𝗲𝗿 Subagent spawning, teammate mailboxes, FSM protocol, autonomous board, and worktree isolation for zero-conflict parallel work. Claude Code isn't a chatbot that writes code. It's a full agent operating system. Understand the architecture, and you'll use it 10x better. Save this. Share with your eng team.
Watch video
- 26
@maheshnani122 ·
How to use Claude Code effectively - CLAUDE. md: Define project rules (Claude reads this first) - Plan Mode: Ask for plan BEFORE coding - TDD Loop: Start with failing tests, go green - Git Worktrees: Parallel feature development - /compact: Keep context clean - /cost: Track token usage - Subagents: Run tasks in parallel - Skills: Reusable workflows for teams
- 27
@zarazhangrui ·
Introducing the Claude Code Lark/Feishu Bridge 🌉 (open-source) Talk to Claude Code in Lark/Feishu like a colleague - Use Claude Code on your phone via Lark chat - Manage multiple CC sessions as group chats in Lark (one chat = one session), say goodbye to messy terminal tabs - Claude Code can read all your work context in Lark (chat, docs, meeting transcripts, etc) via CLI - Claude Code can write Lark Docs for you; you can even @ mention it in the comment and it will reply - Forward any Lark messages to Claude and it can just get the task done - Claude can send you interactive cards with buttons and UI Open-source; try it now: https://t.co/V1eRIg87wx
- 28
- 29
@Shruti_0810 ·
Most people treat CLAUDE.md like a prompt file. That’s the mistake. If you want Claude Code to feel like a senior engineer living inside your repo, your project needs structure. Claude needs 4 things at all times: • the why → what the system does • the map → where things live • the rules → what’s allowed / not allowed • the workflows → how work gets done I call this: The Anatomy of a Claude Code Project 👇 ━━━━━━━━━━━━━━━ 1️⃣ CLAUDE.md = Repo Memory (keep it short) This is the north star file. Not a knowledge dump. Just: • Purpose (WHY) • Repo map (WHAT) • Rules + commands (HOW) If it gets too long, the model starts missing important context. ━━━━━━━━━━━━━━━ 2️⃣ .claude/skills/ = Reusable Expert Modes Stop rewriting instructions. Turn common workflows into skills: • code review checklist • refactor playbook • release procedure • debugging flow Result: Consistency across sessions and teammates. ━━━━━━━━━━━━━━━ 3️⃣ .claude/hooks/ = Guardrails Models forget. Hooks don’t. Use them for things that must be deterministic: • run formatter after edits • run tests on core changes • block unsafe directories (auth, billing, migrations) ━━━━━━━━━━━━━━━ 4️⃣ docs/ = Progressive Context Don’t bloat prompts. Claude just needs to know where truth lives: • architecture overview • ADRs (engineering decisions) • operational runbooks ━━━━━━━━━━━━━━━ 5️⃣ Local CLAUDE.md for risky modules Put small files near sharp edges: src/auth/CLAUDE.md src/persistence/CLAUDE.md infra/CLAUDE.md Now Claude sees the gotchas exactly when it works there. ━━━━━━━━━━━━━━━ Prompting is temporary. Structure is permanent. When your repo is organized this way, Claude stops behaving like a chatbot… …and starts acting like a project-native engineer.
- 30
@alexxubyte ·
If Claude Code is a burger... Before each model call, Claude Code assembles a context window from 9 distinct sources. Think of it as a burger, each layer adds something different. 1. System Prompt: Defines Claude's role, behavior, and tone. This sets the foundation. 2. Environment Info: Git status, branch info, and current date. Pulled in via getSystemContext() 3. CLAUDE.md: A four-level instruction hierarchy: managed → user → project → local. Plain-text Markdown, so users can read, edit, and version-control everything the model sees. 4. Auto Memory: Contextually relevant memory entries prefetched asynchronously. An LLM scans memory-file headers and surfaces up to 5 relevant files on demand. 5. Path-scoped Rules: Conditional rules that load lazily when the agent reads files 6. Tool Metadata: Skill descriptions, MCP tool names, and deferred tool definitions. 7. Conversation History: Carried forward across iterations. 8. Tool Results: File reads, command outputs, and subagent summaries. 9. Compact Summaries: When history grows too long, older segments are replaced by model-generated summaries.
- 31
@smratitiwa86867 ·
Most people think using Claude Code is about writing better prompts. It’s not. The real unlock is structuring your repository so Claude can think like an engineer. If your repo is messy, Claude behaves like a chatbot. If your repo is structured, Claude behaves like a developer living inside your codebase. Your project only needs 4 things: • the why → what the system does • the map → where things live • the rules → what’s allowed / forbidden • the workflows → how work gets done I call this: The Anatomy of a Claude Code Project 👇 ━━━━━━━━━━━━━━━ 1️⃣ CLAUDE.md = Repo Memory (Keep it Short) This file is the north star for Claude. Not a massive document. Just three things: • Purpose → why the system exists • Repo map → how the project is structured • Rules + commands → how Claude should operate If CLAUDE.md becomes too long, the model starts missing critical signals. Clarity beats size. ━━━━━━━━━━━━━━━ 2️⃣ .claude/skills/ = Reusable Expert Modes Stop repeating instructions in prompts. Turn common workflows into reusable skills. Examples: • code review checklist • refactoring playbook • debugging workflow • release procedures Now Claude can switch into specialized modes instantly. Result: More consistent outputs across sessions and teammates. ━━━━━━━━━━━━━━━ 3️⃣ .claude/hooks/ = Guardrails Models forget. Hooks don’t. Use hooks for things that must always happen automatically. Examples: • run formatters after edits • trigger tests after core changes • block sensitive directories (auth, billing, migrations) Hooks turn AI workflows into reliable engineering systems. ━━━━━━━━━━━━━━━ 4️⃣ docs/ = Progressive Context Don’t overload prompts with information. Instead, let Claude navigate your documentation. Examples: • architecture overview • ADRs (engineering decisions) • operational runbooks Claude doesn’t need everything in memory. It just needs to know where truth lives. ━━━━━━━━━━━━━━━ 5️⃣ Local CLAUDE.md for Critical Modules Some areas of your system have hidden complexity. Add local context files there. Example: src/auth/CLAUDE.md src/persistence/CLAUDE.md infra/CLAUDE.md Now Claude understands the danger zones exactly when it works in them. This dramatically reduces mistakes. ━━━━━━━━━━━━━━━ Here’s the shift most people miss: Prompting is temporary. Structure is permanent. Once your repository is designed for AI: Claude stops acting like a chatbot... …and starts behaving like a project-native engineer. 🚀
- 32
@Hartdrawss ·
you should 100% be claudemaxxing i've tried every plugin, wrapper, and github repo promising to give my agent superpowers cursor rules generators, custom mcp stacks, orchestration layers that do things without even telling you whats happening under the hood honestly? i cant tell if any of them moved the needle reason is simple. you get better at something the more you use it. every abstraction layer you add is a thing you stop understanding AI labs are shipping at insane speed. if you're missing a feature, wait 3 weeks. it'll ship. so here's my actual claude setup. no plugins. no wrappers: 1/ cursor for file-level edits. claude code for full feature builds. they do different things, stop using them the same way 2/ supabase MCP connected directly. it reads and writes the db without you copy-pasting schema into every prompt 3/ chrome devtools MCP connected. claude can inspect the dom, read console errors, and debug frontend issues without you relaying anything 4/ write a CLAUDE[.]md file at the root of every project. it loads context automatically every session. no re-explaining your stack, conventions, or rules ever again 5/ ask claude code to write your cursor rules file. let the AI configure the AI. sounds stupid, works every time 6/ use sub-agents for long tasks. one agent plans, another executes. context stays clean and outputs get sharper end of day: ask it to write the git commit message and update the docs. 10 minutes of work you will never do manually again been averaging 10-20% faster task completion since i stopped trying to hack the tools and just learned them Now go claudemaxx !
- 33
@Hartdrawss ·
if you open Claude Code without a structured workflow, you probably hate money. the skill gap isn't knowing prompts. it's knowing which command to run before you touch the terminal. here's the exact workflow I used from @mattpocockuk 1. start with `/grill-me` - paste your app idea or plan - Claude will ask you 16 to 50 questions before it does anything - mine ran 38 the first time i tried it - it walks every branch of the decision tree, resolving dependencies one by one - you fix the broken assumptions before they become broken code 2. move to `/to-prd` - converts the grilling conversation into a proper requirements doc - skips the steps you already covered - doesn't start from scratch - outputs user stories, not implementation notes - lands as a GitHub issue with a triage label - normal team workflow, no AI sidetrack 3. then `/to-issues` - reads the PRD and breaks it into independently-grabbable vertical slices - each issue is tagged HITL (you stay in the loop) or AFK (agent executes solo) - dependency-sorted so nothing blocks anything 4. finally `/tdd` - now the agent writes code. red-green-refactor - can't start green if red hasn't failed - phase-gated. no shortcuts. Hope this helps !
- 34
@sachinrekhi ·
To me it's obvious that Claude Code should be the primary AI productivity tool product managers focus on. But let me spell out what it offers over chatbots like Claude, ChatGPT, or Gemini: 1. It's focused on generating artifacts - documents, reports, and more. These are exactly the deliverables PMs are responsible for. Instead of just using AI for answering questions, Claude Code enables you to use AI to draft the actual work product you are responsible for. 2. It's all about local context in the form of markdown files - Chatbot memory features are pretty limited and unreliable. But Claude Code is brilliant at reading and leveraging local markdown files. Now when you save and organize this context for Claude Code, you give it infinite context and memory. 3. It's fantastic at workflow automation - Claude Code provides a variety of ways, like skills, agents, and commands, to automate an end-to-end workflow so you no longer have to babysit AI while it works, freeing you up to do higher-level work. 4. It can run any command line tool - This enable's Claude Code to do absolutely anything a computer can do. And it does it even faster than using an MCP server. Incredible for advanced workflow automation. 5. It's amazing at writing code for tasks - Claude Code constantly generates bespoke scripts for me to accomplish tasks efficiently without me even needing to ask it to or understand the code. 6. It avoids vendor lock-in - I have ultimate portability to the next hot agent harness or model because all of my context isn't in a proprietary LLM, it's just on my local desktop. For these reasons I've now shifted the majority of my product work to Claude Code.
- 35
@alphabatcher ·
Claude Code creator gave a 24-minute prompting workshop "Anthropic technical onboarding used to take 2-3 weeks" Boris says Claude Code Q&A brought it down to about 2-3 days The order he teaches: 1. Start with codebase Q&A Before edits, make Claude explain the repo Ask: - where is auth handled - how is this class used - how do I instantiate this object - why does this function have 15 arguments - look through Git history and explain why this changed Claude reads files, follows examples, checks Git history, follows linked issues, and explains why the code exists 2. Make it plan before it edits Use this prompt: "Before you write code, make a plan Brainstorm options Name the files you need Ask for approval before changing anything" Claude should explore first, plan second, edit third 3. Give it a way to check its work A coding agent improves when it can see the result Give it: - unit tests - integration tests - Puppeteer screenshots - iOS simulator screenshots - lint and typecheck commands Prompt it like this: "Build this UI Run it in the browser Take a screenshot Compare it to the mock Fix the differences Stop after 3 passes" 4. Put repo context in `CLAUDE.md` Boris says `CLAUDE.md` is loaded at the start of every session Put in: - test commands - build commands - style guide - common MCP tools - important files - architecture decisions - repo-specific gotchas Keep it short Long context burns the session before the work starts 5. Split shared and personal context Shared repo rules go in project `CLAUDE.md` Personal preferences stay local Nested `CLAUDE.md` files can live inside child folders, so Claude pulls in folder-specific rules only when it works there 6. Turn repeated work into slash commands Use `.claude/commands` for repo tasks you repeat Examples: - label GitHub issues - generate release notes - check a PR - run the project test sequence - prepare a weekly shipped summary 7. Use shortcuts while it runs - type `#` to make Claude remember a rule and fold it into `CLAUDE.md` - type `!` to run a shell command and add the output to context - hit `Esc` when an edit is almost right and one line needs changing - hit `Esc` twice to jump back in history - hit `Ctrl+R` to see the same output Claude sees 8. Use `claude -p` for scripts For CI, incident response, or recurring checks: - pass a prompt - allow specific tools - request JSON or streaming JSON - pipe into it and out of it like a Unix utility
Watch video
- 36
@zaimiri ·
the guy who built Claude Code runs a 100-line CLAUDE.md you don't need 800. boris cherny is a staff engineer at anthropic. he created the tool. he runs 10-15 sessions in parallel daily. his file is ~2,500 tokens. the 6 rules he actually uses: > plan mode before every task > subagents for parallel work > verify before calling anything done > demand elegance, no hacks > fix bugs autonomously without asking > self-improvement loop that last one is the real weapon. every time claude makes a mistake, they add a rule. his exact instruction: "after every correction, end with: Update your CLAUDE.md so you don't make that mistake again." the ai gets better on YOUR codebase. not just in general. specifically yours. he hasn't written a single line of SQL in 6+ months. claude pulls bigquery data directly via cli. everyone's building custom frameworks. the creator uses a text file. key lesson: keep it under 200 lines.
- 37
@GithubProjects ·
Claude Code Showcase is a reference repo demonstrating how to fully configure Claude Code with agents, skills, hooks, and automated workflows. - Shows how to structure a .claude setup with agents, commands, hooks, and skills. - Automates tasks like PR reviews, code quality checks, and documentation sync via workflows It shows how to turn Claude Code into a system that actively manages and maintains a codebase, not just assists with coding
- 38
@rohanpaul_ai ·
Head of Claude Code Boris Cherny at Anthropic's annual developer conference in San Francisco on how his life changed in the last 6 months with AI writing all the code. "About 6 months ago what happened is all the code that I used to have written by hand now Claude writes. And I just prompt Claude. So I talk to Claude and I'm like, hey, let's build this feature. It builds a feature and it tests it. And then it shows me. And I'm like, yeah, that's good. Or no, wait, make this change. And then it makes the change. " --- From 'CNBC Television' YT channel (link in comment)
Watch video
- 39
@JustAnotherPM ·
Two Anthropic engineers who built Claude Code sat down and showed every feature most users have never touched. Bookmark this. Come back to it this weekend. Here is what they covered: 𝟭. 𝗠𝘂𝗹𝘁𝗶-𝗳𝗶𝗹𝗲 𝗲𝗱𝗶𝘁𝗶𝗻𝗴. Claude Code rewrites across your entire codebase in one pass. Not file by file. 𝟮. 𝗦𝘂𝗯𝗮𝗴𝗲𝗻𝘁𝘀. Spawn background agents that research, test, or review while you keep working in the main session. 𝟯. 𝗗𝗼𝗼𝗸𝘀. Set guardrails that run before or after every tool call. Block destructive commands automatically. 𝟰. 𝗠𝗖𝗣 𝗶𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗶𝗼𝗻𝘀. Connect Claude Code to Slack, GitHub, databases, and any API with one config file. 𝟱. 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱. The file that turns a generic model into a teammate who knows your project, your standards, and your shortcuts. 24 minutes. Free. From the people who built the tool.
- 40
@smratitiwa86867 ·
Most people are using Claude Code like a chatbot... while others are turning it into a full execution system. This diagram is the difference. It shows how top devs are structuring Claude projects to actually ship faster — not just generate code. At the center is one file: CLAUDE.md This is the brain. It holds: • project context • architecture decisions • coding standards • workflows Claude doesn’t “guess” anymore — it follows a system. Then comes the real leverage: Skills, Hooks, MCP, Subagents This is where it gets serious. • Skills → reusable automations (review, refactor, test) • Hooks → enforce rules before/after actions • MCP → connect external tools (GitHub, DBs, APIs) • Subagents → parallel task execution You’re not prompting. You’re orchestrating. And once this is set up: /review → full PR analysis /deploy → build + push /test-all → run full suite /bootstrap → scaffold modules One command = entire workflow. This is the shift most people still don’t see: Beginners → ask AI for answers Advanced → build systems that run on AI Same tool. Completely different output. Claude Code isn’t powerful because of the model. It’s powerful because of the structure around it. And this is what 99% of people are missing
- 41
@CodeByPoonam ·
90% of people are using Claude Code wrong. Anthropic's internal workflow is just 4 steps: → Explore (Plan Mode, zero changes) → Plan (detailed implementation plan before any code) → Implement (with tests so Claude verifies itself) → Commit (let Claude own git too) Most people skip the first two and wonder why results are inconsistent.
- 42
@Shruti_0810 ·
99% of people are using the wrong Claude. Anthropic launched Claude Code and Claude Cowork... Almost everyone thinks they're the same product. They're not. Here's the simplest way to think about it: • Claude Code → builds software • Claude Cowork → gets work done One ships code. One ships outcomes. Same intelligence. Different interface. Claude Code lives in your terminal. It can: Read entire codebases Run tests Fix bugs Commit code Handle developer workflows Claude Cowork lives inside the Claude desktop app. It can: Organize folders Read documents Extract data from PDFs Research across the web Draft reports Automate repetitive tasks The crazy part? Anthropic says Cowork was built using Claude Code. Same brain. Different hands. If you're a founder, creator, marketer, lawyer, analyst, or operator... You probably don't need Claude Code. You need the one that finishes your work while you're doing something else. AI is quickly moving from answering questions to owning outcomes. That's the real shift.
- 43
@rostikdeni ·
THE CLAUDE CODE CREATOR JUST RELEASED WHAT AN AI AGENT NEEDS TO KEEP WORKING In this 50-minute YC conversation, he maps the operating layer around an agent: 0:00 - Why Anthropic builds for models six months ahead 9:00 - The instructions inside his CLAUDE.md 23:48 - Subagents and parallel work 25:12 - Plan mode before execution 28:38 - The frontier founders should build for 40:31 - What changed once agents owned more of the code 44:46 - How software work changes from here Full loop breakdown below
Watch video
- 44
@Axel_bitblaze69 ·
You need to master these 12 concepts to unlock the full potential of Claude Code 1) CLAUDE.md - write your project's rules once. claude reads them every session so you never repeat yourself. 2) permissions - what claude can do on its own vs what it has to ask you first. 3) plan mode - it shows you the plan before touching code. approve, then it builds. 4) checkpoints - save points. something breaks, you roll back instead of starting over. 5) skills - save a workflow once, trigger it by name forever. 6) hooks - scripts that fire automatically on events. your guardrails. 7) MCP - how claude plugs into outside tools. github, databases, your browser. 8) plugins - skills, commands and MCP servers bundled into a one-click install. 9) context - everything claude can "see" right now. it has a limit, so manage it. 10) slash commands - quick "/" actions. built-in or your own. 11) compaction - when context fills up, claude summarizes it so the session keeps going. 12) subagents - it spawns helper agents that work separately and report back. learn these 12 and you stop "using" claude code and start running it. save this.
- 45
@alphabatcher ·
Claude Code now includes computer use on macOS, letting Claude control apps directly from the CLI to test and debug what it builds
Watch video
- 46
@alvinfoo ·
How one of the top creators of Claude Code actually uses Claude every day. Boris Cherny (Creator of Claude Code) has turned Claude into a full-blown engineering superpower. Here’s exactly how he does it: 1️⃣ Runs 5 Claude sessions in parallel Five windows open at once. A custom “Stop hook” pings him the moment one needs his input. 2️⃣ Works seamlessly across devices Starts on desktop (https://t.co/G8wxO4Ex8P), continues on the iOS app without losing context. 3️⃣ Always picks Opus + Thinking mode Slower per turn, but fewer retries and faster overall output. 4️⃣ One shared CLAUDE.md file The entire team maintains a single rules file in the repo. Every mistake = new rule added. 5️⃣ Tags @claude in pull requests Claude reviews PRs and automatically updates CLAUDE.md based on feedback. 6️⃣ Plan Mode before execution Shift + Tab twice → Claude plans first. Only then does he let it ship. 7️⃣ Slash commands for repetitive tasks Every repeat workflow becomes a slash command. One command now handles the full Git flow: commit → push → PR. 8️⃣ Sub-agents for parallel jobs Spawns specialized sub-agents (code simplifier, verify-app, etc.). 9️⃣ –dangerously-skip-permissions Runs Claude in a sandboxed environment so permission prompts never break the flow. 🔥 Most important tip from Boris: “Give Claude a feedback loop to verify its own work. It 2-3x’s the output quality.” 10️⃣ Plugs directly into team tools Sends Slack messages, pulls company data, checks error reports, same tools the human team uses. This isn’t just “using AI.” This is building an entire AI-powered engineering system.
- 47
@titus_k ·
A bit of Friday navel-gazing with Claude: /insights: How You Use Claude Code You are a prolific, delegation-heavy operator who uses Claude Code as a full-stack execution layer across a wide range of tasks — from CRM syncs and git operations to landing page copy, documentation migrations, and even strategic planning. Across 56 sessions in under a month, you average roughly 10 messages per session but accumulate massive tool usage (500+ edits, 450+ bash commands), suggesting you give Claude long-running, multi-step tasks and let it execute with minimal interruption. Your top goals — git operations, copy editing, and content edits — paint a picture of someone managing a fast-moving startup (Civic) where Claude handles the operational grind: branching, PRing, syncing CRMs, bulk-updating repo links across 14 files, and migrating 14 repos between GitHub orgs. Your style is iterative refinement rather than detailed upfront specification. You'll kick off a task with a general direction, then course-correct through rounds of feedback — visible in sessions like the landing page rewrites (15+ iterative copy edits), the pivot strategy docs, and the hero copy where Claude needed two rounds to nail the right tone. You're not afraid to reject output that misses the mark ("too dev/process-focused"), but you're also patient enough to let Claude self-correct on technical issues like the ISO datetime bug or CRM data swap. Your friction patterns confirm this: 19 instances of wrong approach are by far your top friction type, but your satisfaction remains overwhelmingly positive (211 satisfied vs 16 dissatisfied), meaning you treat these course corrections as a normal part of your workflow rather than failures. You rarely interrupt (only 3 times) and almost never reject actions outright, preferring to guide Claude back on track with concise redirects. You also stand out for your breadth of task types in a single tool. You're not just coding — you're building presentation decks, running pipeline reports, designing eval frameworks, enriching CRM data from Gmail, and orchestrating multi-agent research debates. The MCP Redis tool in your top-8 and the Civic MCP integrations show you're building custom infrastructure around Claude Code itself. With a 74% fully-achieved rate and 35 commits across the period, you treat Claude as a high-autonomy junior team member who you trust to execute end-to-end but review before merging. Key pattern: You delegate broad, multi-step operational tasks and refine iteratively through rounds of feedback, treating Claude as an autonomous executor you steer rather than micromanage.
- 48
@shivsakhuja ·
Level 0: Write code by hand Level 1: Single-clauding (single claude code session) Level 2: Multi-clauding (multiple claude code sessions running in parallel) Level 3: Auto-clauding / code factory (claude code automatically coding) Simple examples of auto-clauding: - Sentry → tickets → Claude Code → PR - QA agent → tickets → Claude Code → PR What's next?
- 49
@0xDvnl ·
Most people treat Claude Code like a chatbot that writes code. Here's how I actually set it up: 1. Give it account-level access to Vercel and Supabase. No more copy-pasting queries and deployment configs back and forth. 2. Spin up a sub-agent just for QA. It reviews everything the main agent builds. Catches things before you do. 3. Connect it to https://t.co/IVgekVmkXe. Your coding agent can now request custom-generated images, icons, illustrations — and implement them directly. No more emoji placeholders. No more generic stock assets. 3x perceived UI quality overnight. The principle: think WITH Claude, but empower it to build nearly autonomously. You're the architect. It should have its own tools.
- 50
Best Tweets by Topic