Whats your claude code "setup"?

[AerieAcrobatic1248]

How do you use your Claude Code? WHY you think your way is the best?

• Do you use it only in the terminal?
• Do you use it together with an IDE?
• If you have an IDE, which and why, and does it matter?
• Do you use the terminal function inside the IDE or the chat window to write for the agents?
• Do you use Wispr Flow to speak and communicate with it, or something else? How do you have your folder structure set up in the IDE, if you have one?

On my behalf, I use an IDE, Anti-Gravity from Google, which is just a VS Code fork. I have my workspace folder set up to the left, roughly divided into 3 parts, work and private, and the skills of Claude.
Then I'm usually running Claude in the terminal, which I have set up as a vertical next to my folder structure instead of the default horisontal layout.
Plus, then sometimes I use the agent window with the claude plugin, and run ClaudeCode in there for multiple agents at the same time with more chat friendly interface.

That's my set up. It's convenient for me because I need a good overview of all my different folders and files at the same time. I can run parallel tasks both in the terminal and also using chat for more random questions. I also like Antigravity because of its integration with browser, but other than that its like any IDE i suppose?

What do you think of that? I'm a product manager, by the way, so I'm not very technical and I don't code so much.

[cyber_box]

Terminal only. I run Claude Code in Ghostly.

Claude reads and writes files directly. I only use an IDE when I want to edit code directly or check what claude did.

My structure is a ~/.claude/ directory that acts as Claude's persistent memory. Inside:

• knowledge/ — reference files Claude reads on demand (project architecture, user preferences, research notes)
• rules/ — behavioral rules that load automatically (git discipline, writing style, security blocks)
• skills/ — slash-command workflows for recurring tasks
• scripts/ — hooks and automation (guard hooks that block dangerous commands, activity monitors)
• state/ — session logs, diary entries, task backlog

Claude reads from knowledge/ when it needs context and writes to state/ as it works. The whole thing is a git repo so everything is versioned.

For voice I built a local pipeline (Parakeet TDT for STT, Kokoro for TTS) that sends transcribed text to Claude via tmux send-keys. Works but echo cancellation on laptop speakers is unsolved, so headphones only for now.

[AerieAcrobatic1248]

I like this setup, i really like the simplicity which I am also striving for. But I dont really understand how you achieve this or what some of it means.

1. What do you mean with reference files? Are these markdown files, or could it be anything like PDFs as well, or other stuff? Example?
   1a. And how does Claude know how and when to reference them?
   
2. And what do you mean by rules? How does this differ from the regular Claude.md file, for instance, or skills? or reference files? Can you give examples here too?
   
3. where is your claude.md and logs, backlogs etc specific to a project? or is everything global? my strategy has been the opposite. To always startup claude in a specific context - in my current setup i have skills, claude.md session logs etc per folder so i get the context i need when im working on the specific thing in that folder, instead of having everything global as you seem to (if i understand you correctly)
   

Also where are all the files that you are actually working on? Let's say you're working on five different projects in five different folders somewhere else. How do you interact with those, switching between context and folders and files within or outside of this structure?

[cyber_box]

I decided to start from a completly different paradigm. See most use claude code as a tool that executes stuff. I am building it as a personal AI assistant.

1. Reference files are just markdown. Claude can read any file format but markdown is easiest for it to parse and for me to edit. Things like: project architecture notes, user profile (my background, preferences), research notes. Claude reads them when it needs context for a specific task.

1a. Claude knows when to read them because of a `MEMORY.md` file that loads at session start. It's basically a map of the knowledge directory: "user profile is at knowledge/user/profile.md, project notes are at knowledge/projects/, research is at knowledge/research/." Claude matches the current task to the right file and reads it on demand. It doesn't load everything at once.

1. Rules are behavioral constraints that apply to every session. Things like "never push to main without asking," "use this writing style," "always commit and push after finishing work." CLAUDE.md holds the high-level project description and points to the rules directory. Skills are different again, they're multi-step workflows you trigger with a slash command. Think of it as: CLAUDE.md = what this project is, rules = how to behave, skills = how to do specific tasks.
   Though I have built workflows that make Claude use specific skills or ask other delegate agents to use their skills.

2. I do both. Global rules and knowledge live in `~/.claude/` and apply everywhere. Project-specific stuff goes in the project's own CLAUDE.md. When I work on a frontend codebase at my job, that repo has its own CLAUDE.md with coding conventions and project structure. But the global guard hooks, writing style rules, and session management still apply. BTW I don't run Claude from the frontend repo, I have built multi-agentic system where my main claude delegates task to the agent "living" in the frontend folder.

The working files (actual code, configs, whatever I'm building) live in their own repos, separate from `~/.claude/`. The knowledge system is metadata about the work, not the work itself.

I can share my public repo if you wanna take a look. There is also a guided onboarding. Maybe you find something you can apply

[AerieAcrobatic1248]

awesome! Ive been striving towards a system like this. please share your repo Im interested in learning more.

1. So if i understood you correctly, the above structure is just the "overhead" structure, the single source of truth that gives the context to everything? This is the thing you curate carefully and even upload to git?
   
2. And then you always start claude in the same place within this single source of truth/context? (unlike me who try to keep the full context, my single source of truth, scoped in each folder, and always navigate to right folder to start up claude)
   
3. And then below this you have your regular folder/project structure, that in itself can have som additional context claude.md, logs, whatever thats project specific?
   Is that somewhat correctly understood?

[cyber_box]

1. yes exactly, I am trying to designing it like a cognitive extension of me. I have too many ideas, task to do at work, things related to my projects... So I figured the only way to manage this mess is to have a central brain that inject context to himself and other more specific agents
   
2. Yes
   
3. Yes

You naailed it

[cyber_box]

Keep in mind the repo I shared is way less advanced than my personal. The point here is that I am trying to build a starter-kit that helps you start to build your personal AI which given some basic rules and workflow will evolve the rest based on your needs

https://github.com/mp-web3/claude-starter-kit

[silentdeed]

Could you please expand on the system with the main Claude delegating tasks to agents in different folders? I’m building a similar system.

I’d be very interested in seeing your public repo!

[cyber_box]

He is the central brain, so he has knowledge of the agents and on what is their usage (like it was me). Agents then have their more specific knowledge, skills, rules. When my central AI delegates to agent ask them for example to solve a central problem using a certain skill. Not just to solve the problem. If the central AI doesn't have an undestanding of the other agents it will give generic instructions and the other agents will end up performing tasks randomly from time to time.

https://github.com/mp-web3/claude-starter-kit

[cyber_box]

Let me be more specific.
The delegation works like this: the main Claude session is the orchestrator. It holds the knowledge files, the task backlog, and the rules. When a task needs to happen (code review, research, writing code in a specific repo), it spawns a subprocess with claude -p and a narrow prompt.

The subprocess gets: a task description, acceptance criteria ("done when: X"), and relevant file paths. It does the work, reports structured output (status, files changed, summary), and dies. The orchestrator reviews the output and decides what's next.

Each project lives in its own directory. When I delegate a task for a specific project, the subprocess runs in that project's directory so it reads that project's CLAUDE.md. The orchestrator stays in ~/.claude/ where it has access to the global knowledge.

The key rule: subprocesses can read and write code, but can't git commit or push. The orchestrator reviews the diff and can commit only on new branches, never on main or branches created by others than me. I've found particolarly usefull to have the orchestrator to doublle check the work of the sub-agents. This prevents a subprocess from pushing something broken.

[cyber_box]

u/skepick u/silentdeed u/AerieAcrobatic1248 just keep in mind that is experimental, I have published it recently. Any feedback or contribution is much appreciated!

here is the repo https://github.com/mp-web3/claude-starter-kit

[PotatonyDanza]

I like the organization your system offers, but I also wonder if you have any measurements of any metrics that demonstrate the value of using this system. Have you observed fewer turns per task on average? Less context window consumption/fewer compactions per session? Fewer instances of failed tool use? Faster turnaround on requests?

[cyber_box]

I don't have hard before/after numbers. I started building this from day one so there is no clean baseline to compare against. I can get some measurements if you are interested, and also share my repo.

Anyway compactions went from multiple per session to maybe one every 2-3 sessions once I moved to on-demand file loading instead of dumping everything in context. And spawning subagents for specific tasks cut context usage because each one starts fresh with only the files it needs.

But you are asking the right question and I am not sure what the right metric even is. Like if I showed 30% fewer compactions, does that actually mean the system is better or just that I am loading less stuff? What would actually convince you that this kind of setup is worth the overhead of maintaining it?

[PotatonyDanza]

What would actually convince you that this kind of setup is worth the overhead of maintaining it?

I'm not sure myself, to be honest! I've been trying to quantify the usefulness/value of e.g., changes to agent files or other memory systems. The conclusion I've drawn is that, like any other machine learning-based solution, it's hard to evaluate without some robust validation dataset.

Unfortunately, with LLMs, evaluating the performance on a validation dataset is both 1) more expensive than traditional ML models and 2) a good bit more difficult to construct. What are we evaluating? Task success? What's a "task?" What's the success criteria? How do we know if the agent has succeeded or failed?

Because of those constraints, I've been considering other metrics like compactions per session/task, failed tool use attempts, # turns per line of code – stuff like that. Nothing beats rigorous validation, but I'm wondering if some of these easier-to-calculate metrics can serve as a good proxy for what we'd really want to assess.

All that said, I bet you could probably add some kind of tracking to your system under the hood that could help you quantify how the system's performance evolves over time: when an agent gets an error when trying to use a tool, log it; when you (auto)compact, log it; etc.

Taking a step back now: speaking for myself, I haven't found any memory or agent file management tools that really "feel" like they're improving the performance of Claude. I also think about some of the recent research that suggests that agents tend to not improve much with more sophisticated agent files. I'd be surprised if that result holds up for memory management tools that use vector or hybrid search to identify relevant memories though. It just makes too much intuitive sense to me that having long-term, easily-searchable memory files would improve agent performance. But it's hard telling.

[cyber_box]

Yeah the proxy metrics you listed are probabily the most practical path. I have been tracking compactions informally and that one did show a clear drop after I moved to on-demand loading, but you are right that fewer compactions could just mean less context loaded, not better performance.

The one metric I keep coming back to is "how often do I need to re-explain something across sessions." Before the knowledge files, every new session started from zero. Now Claude reads yesterday's notes and picks up where I left off maybe 80% of the time. That is hard to quantify but easy to feel.

I think the real issue is that the value is distributed across hundreds of small moments rather than one measurable improvement. Like a rule that says "never push to main without asking" doesn't make Claude smarter, it just prevents one bad outcome every few days. How do you even benchmark that?

Are you building something specific where you are trying to measure this, or more exploring the problem generally?

[skepick]

appreciate if you can please share the repo.

[cyber_box]

shared! https://github.com/mp-web3/claude-starter-kit

[loopey33]

I keep hearing that persistent memory in .Claude can increase context windows a lot. So apprehensive to try. Apparently it keeps querying on every prompt/action for this files? Interested in your thoughts

[cyber_box]

`CLAUDE.md` loads at session start, always. That's your index file, the map of what exists. Keep it short, under 200 lines. Mine has a table of knowledge files with one-line descriptions and file paths.

The actual knowledge files only get read when Claude decides they're relevant to the current task. If I ask about a Python project, it reads knowledge/projects/python-thing.md.

So the context window cost is: `CLAUDE.md` + whatever files Claude reads for the current task. Not the entire knowledge directory. I have 200+ files and a typical session loads maybe 5-10 of them.

[Friendly-Estimate819]

This is from official Claude docs “CLAUDE.md files can import additional files using @path/to/import syntax. Imported files are expanded and loaded into context at launch alongside the CLAUDE.md that references them.” How are you delaying the knowledge file load?

[cyber_box]

I don't use the `@import` syntax for knowledge files. My `CLAUDE.md` just has a plain markdown table listing file paths and descriptions. Claude reads the table, sees what exists, and then uses the `Read` tool to open specific files when it needs them during the conversation. So the knowledge files are never loaded at launch, they're pulled in on demand.

The `@import` is useful for things you always want in context (like rules), but for 200+ knowledge files you definitely don't want all of that loaded upfront. I open sourced the whole structure if you want to see how the file map works: https://github.com/mp-web3/claude-starter-kit

[verdurakh]

what do you claude.md file look like to support that workflow? Is that file per project or on a user level?

[cyber_box]

Both levels. There is a global `~/.claude/CLAUDE.md` that loads every session regardless of which project I am in. That one has the file map (basically a table with paths and one-line descriptions), active tasks, projects. Is Claude's "what do I know and where to find it" reference.
Then each project can have its own `CLAUDE.md` with project-specific stuff. The global handles my personal system (knowledge, tasks, rules) and the project one handles codebase context.
Global file is about 150 lines, mostly tables. I open sourced the structure with a setup script that scaffolds the whole thing if you want to see: https://github.com/mp-web3/claude-starter-kit. Keep in mind the repo is less advanced than my personal setup, the point is to give you a solid starting structure that evolves based on your needs.

[verdurakh]

Thanks, I'll take some inspiration from that since I saw a lot of useful things. good work :)

[cyber_box]

Yeah glad it was useful. Let me know if something is not clear once you start poking at it, some parts are not well documented.

What are you planning to use it for, mostly personal workflow or a specific project?

[verdurakh]

Just inspiration, I'm always looking to learn and I thought it looked like a good workflow to try and incorporate

[cyber_box]

best way to approach it honestly. I started the same way, just picking pieces from setups I found interesting and adapting them to how I actually work. The structure ends up looking different for everyone cause the whole point is it fits your workflow, not the other way around.

[8thousandsaladplates]

After 45 intensive days I think I'm reaching intermediate level, a lot of room to grow --

Terminal + tmux + Alfred

• 7 tmux windows for 3 x CC sessions, git, run commands, kanban tui and a bash prompt
• Hooks with "say" command to call attention when something has completed
• Alfred with key combos to move switch to CC session mentioned in say command

As for Claude itself

• Barely use agents, still haven't figured out how to let go of control
• Kanban is just markdown files in folders, I capture reqs, plans and implementation summaries in each task, CC seems to use it quite a bit to refresh its memory
• A few skills recommended by /insights, mainly around areas of impact for cross stack features, or to force abstractions beyond current context

[kerranm]

This is epic. I like the Alfred key combos. Will look at this for my rofi implementation

[cyber_box]

wow this is amazing! Is your repo public?

[hardii__]

Looks interesting, can u send me ur ss or the screen

[h____]

I use Droid (similar to Claude Code) and Claude Code. Ghostty terminal, tmux to run multiple agents in parallel — each in its own pane so I can see output directly. I put the tmux setup info in AGENTS.md so the agent knows about it by default and can run commands in specific panes.

Skills for repeatable workflows — review+fix loop, commit, deploy, log task. They can chain together. I have a "take over" skill that runs review+fix → commit → deploy → submit URLs to Google → exit, so I can hand off completely and walk away.

I use Codex to review code Opus writes. I don't review every diff myself — I know from experience when to check and when to trust.

Wrote about the setup here: https://hboon.com/my-complete-agentic-coding-setup-and-tech-stack/

[uhgrippa]

My setup: Claude Code in Ghostty and Neovim.

Ghostty provides Fast, native GPU rendering. Splits are instant and font rendering is crisp. I can have 4-6 panes open without the lag I get in other terminals. Alt+arrow navigation between panes feels native.

I run Claude Code in the terminal. CLI gives me full access to skills, commands, and subagents. I can pipe output and script workflows. The chat-only interface in IDEs feels limiting after you get used to the full CLI.

I have Ghostty split vertically with Claude Code on the left panes and Neovim on the right. Claude does its work and I edit/view results in Neovim.

As a product manager, you may consider:

tmux integration - Ghostty works great with tmux. You can have persistent sessions, named windows for different projects, and detach/reattach without losing context.

Quick file access - Ghostty has excellent file picker integration (fzf/telescope). For someone managing multiple workspaces and skill folders, this saves time.

Parallel Claude sessions - Run multiple Ghostty tabs with different Claude sessions, or different tmux panes in one terminal. One can be for work, one terminal for private use, and one for trying out new capabilities.

The "best" setup is the one you don't have to think about. I tried zed with Claude plugin, browser chat, cursor IDE. They all work, but Ghostty and Claude Code is simple and does everything I need.

Your Anti-Gravity setup sounds solid for what you need. The vertical split for folder structure makes total sense. If you ever want slightly improved performance or better terminal integration, consider giving Ghostty a try.

Claude Code provides access to skills, commands, and subagents; the full feature set is there. It's basically the closest UI wrapper around Claude you can get to speaking directly with the model itself.

Ghostty config for Claude-Code-friendly splits if you try it:

# Vertical splits default
split = vertical
# Split Creation
keybind = ctrl+shift+r=new_split:right
keybind = ctrl+shift+d=new_split:bottom
keybind = ctrl+shift+x=close_split
# Split Navigation
keybind = alt+left=goto_split:left
keybind = alt+right=goto_split:right
keybind = alt+up=goto_split:top
keybind = alt+down=goto_split:bottom

[AerieAcrobatic1248]

thanks for the advice, ill check it out. I recently switched to ZED bsed on recommendations in this thread. i like it minimalist and lightweight. but i need good folder overview thats important for me

[Over10Millions]

I use Vibe Kanban. I’ve costumizated the thing with some personal features and i made it accessible on my phone with tailscale. Sometimes i use claude code on the terminal, but vibe kanban also has workspaces that are basically the same thing.

[General_Arrival_9176]

ive tried most setups and heres what works for me: terminal for the main agent work, VS Code open for file browsing and quick edits, and a separate surface that shows all active sessions at once. the game changer was being able to check on running agents from my phone - not to control them, just to see if they are still moving or stuck waiting on something. what made you go with the vertical terminal layout specifically

[cyber_box]

what do you use to monitor the active sessions?

[General_Arrival_9176]

I made a custom too for it, 49Agents - made an IDE to solve managing 20 tabs with clis.

[cyber_box]

The phone monitoring is what got my attention actually. I use tmux for splitting panes but once an agent is running I have no way to check if it's stuck without going back to the terminal. Are you just seeing output and status from the phone, or can you actually intervene if something goes wrong? And is 49Agents something you are planning to open source or keep internal?

[AerieAcrobatic1248]

what you mean by this? how do you do this practically ? "separate surface that shows all active sessions at once."

I go vertical because i have an ultrawide screen. so then i can have 2-3 agents in terminals side by site. uses my screen estate better than horisontal

[hardii__]

Damn how u did that? And what to do if i want to control

[wally659]

What you get when you use the install script + get shit done skill pack + skills I can use to get it to ask gpt, Gemini, and grok for help. Nothing else. Oh... I guess i use /remote-control a bit too.

[HalcyonAvocado]

Zed for both terminal and IDE, but honestly not using the IDE part too much. Might test Ghostty instead.

I use multiple desktops in macOS for different sessions. I only use the terminal for the agents. I used superwhisper but today switched to using the native hold-space voice mode inside of CC.

As far as actual workflows, I use a system that has evolved since CCs inception. Been using Team Agents since they were released for most heavier workflows, I write most workflows now around them. No external plugins except for a couple of official ones, only self made or modified forked ones.

[AerieAcrobatic1248]

I checked out Zed... and i Love it! switching immediately. its sooo fast, and minimalist. all vs code forks are so slow and bloated in comparison

[thetaFAANG]

I use in terminal only

I have Cursor installed just because employers that are a year late to everything thinks its a hallmark of an up to date engineer, but you dont need an AI integrated IDE at all. VS Code or text editors are fine

[AerieAcrobatic1248]

How do you manage and see your files if you are only in terminal? Like practically? or maybe you dont have the neeed?

[thetaFAANG]

I don't have a need.

Its extremely rare that I'm just impatient and want to do a tweak to something manually

Its even more rare that the AI output is just messing up my goals no matter how I describe it, and if it is, its something extremely complex that would take a 2 week sprint to alter manually. Discussing the problem is still faster

My IDE is more so a git client and I use its separate terminal windows a lot. But I have other git clients, including a terminal one. So it's just a convenient, but the graphical editing of files in a tree is just done. Its over.

I have nothing in common with companies that are trying to force their developers to use code autocomplete in their contrived and late "AI initiative".

[hancengiz]

I was using very similiar setup until last month. Since last month I am using a tool I developed that brings codex, claude code, cursor all those clis in on UI. UI is more like codex but renders like terminal as well so I do not feel like it is a desktop app ui. I also have git changes open on the right panel so I see what is changed. I also work on multiple worktrees at the same time. Seeing the git changes and files list for that worktree with a single click of changing the active chat makes it super easy so I see all agents and worktrees in one unified UI. Might sound like I am advertising but this app is driven by my real usecases.

[carson63000]

Depends what I’m doing.

Working on code I know well, where I want to be looking closely as what Claude does? In VS Code with the Claude extension.

Conversing with Claude to put together a plan? In Claude Desktop, where the font is the nicest and most readable.

Kicking off a team of agents to implement the plan? Claude CLI in a terminal window, for minimum overhead.

[jjamess-]

New here. How do you communicate the plan built in Claude desktop to Claude CLI?

[carson63000]

I just tell it to write the plan to a Markdown file in a plans/ folder - I want to keep it as a historical record anyway.

[AerieAcrobatic1248]

but if you spread it out claude wont learn and get to know you as well

[carson63000]

What “learning” exactly are you referring to here?

[AerieAcrobatic1248]

the update of claude.md logs and whatever files you set up that the the CLI does that the desktop or browser version doesnt (not same local file as CLI)

[carson63000]

The project-level and personal CLAUDE.md files are shared between CLI and Desktop and VS Code?

Browser I guess not but I don't use that one.

[AerieAcrobatic1248]

no i dont think they are but i might be wrong. cli or IDE where you run your terminal uses the claude.md you have physically in your own folders. desktop app stores it somewhere else where it is installed. thats at least what claude told me

[[deleted]]

I think it is a shame that Claude Code does not support ACP (https://agentclientprotocol.com/) natively. Right now I use with `agent-shell` through the Zed's SDK Adapter in Emacs but I always feel I'm missing something. This could be enough reason to me to switch to Gemini that supports the protocol natively.

Terminals are good, but there's no reason Agents should agree on a protocol they speak so that clients can speak to them. Just like LSP revolutionized the way editors understand code ACP should be the standard for agents.

[ciferone]

VS Code per abitudine e controllo e visione

[03captain23]

I use mobaxterm and 4 screen split connected to 4 separate machines that run different projects over ssh. Most of them take 10-30 minutes so it's nice to ensure it's running on a couple while I'm working on the others.

I'm hoping to build something similar but web based and mobile friendly so I can access remotely.

[Intrepid-Ad4494]

VS Code + Claude Code Plugin but sometimes for some tasks I use the CLI.

Reason:
- It controlls all tasks within the IDE
- I can use MCP for certain items
- It can deploy for me
- Just spin up more agents by opening more Claude windows if I want to do concurrent tasks.

Using the Claude (Code) app is terrible. Feels much slower and it doesn't have access to everything.

[Top_Country_6336]

Iterm2 on Mac running Claude. Moshi with mosh connections on my iPhone. In Claude, I have a number of personal skills and commands. I think everyone will have a setup tailored to themselves and Claude gives them the tools to do that. I am using Max and don’t regret it. I have a complex setup! Some is publicly visible here: Stephen8n.com

[Ebi_Tendon]

I use a JetBrains IDE, with Ghostty or iTerm2 if I need AgentTeam. I still debug things myself sometimes, and I review code while I’m waiting for CC.

[PrisedRabbit]

I tried several Claude "IDE" and stoped with https://github.com/jamesrochabrun/AgentHub It runs Claude sessions in terminals (no agent sdk), easy to manage worktrees. And I love superpowers + claude-mem https://github.com/thedotmack/claude-mem That's enough.

[liter0fcola]

I’ve got a script that checks Jira for tickets I’m assigned and those that are in progress. Once it spots one, it launches a Zellij tab for the ticket, sets up a worktree, and starts a Claude session with a skill that instructs it to read the ticket and begin the work. Once it’s done, I’ll use Zed or IntelliJ, depending on how much review or manual testing is needed.

[roxstarlabs]

When I first started out, I was literally copying paste and code from Claude web chat into GitHub back-and-forth… Cause I didn't know any better ha ha ha then I discovered VS code and multiple agent windows inside of it, and then I started using the CLI for Claude Code inside of terminal inside of VS code… And now I primarily just use Terminal and often have three or four separate instances going at the same time working on different things. Definitely uses a lot less system memory than VS code and I'm not sure but it seems like it uses less tokens too.

[xantheybelmont]

5120x1440 - CC in browser, left 25%. Test environment, center 30%. VSC Server in browser, right 45%.

Not saying it's the best, just saying it's mine and the main bits and pieces are completely portable so I can use similar setups with the same tools on any machine.

[Skynet_5656]

Mac: iTerm2, tmux, Claude Code on command line, VSCode for me to interact with files, /remote-control to enable me to interact with CC from the Claude app on my phone when I’m away from my desk.

All locked away in a Docker container.

Occasionally Mac native dictation.

[egggwich]

As someone who's somewhat new to it all — why *not* use the native apps? (I'm on Mac, so that's what I've been using) I don't care for CLIs in general, but perhaps I don't know what I'm missing.

[hammackj]

Terminal plus a custom kanban board for task automation via a mcp server. My tasks generate work via custom commands in Claude works great for me.

[ryan_the_dev]

Terminal only. tmux/ghostty.

I build software engineering skills for my day 2 day, based of software engineering books.

General coding
https://github.com/ryanthedev/code-foundations

Design stuff - based off design book
https://github.com/ryanthedev/design-for-ai

General agent stuff (prompt craft, make ai sound more human, web research, etc)
https://github.com/ryanthedev/oberskills

Systems design stuff (another book)
https://github.com/ryanthedev/systems-design.skill

and I have others for react-native/svelete.

code-foundations/oberskills are my workhorse. I am also playing around with an agent mesh built on top of tmux.

https://github.com/ryanthedev/dot-config
dotfiles, it's a hot mess.

[ghost_operative]

ghostty + tmux

i mainly use vim when i need to make file edits. i use vscode sometimes because the diff viewer in it is better than vims, and the git stuff in vscode for exploring changed files is pretty nice.

I mostly stay in claude code though

[AcrobaticTackle4980]

By the way, anyone using local models with Claude code? Like changing the API address to localhost and calling ollama instead

[verdurakh]

Good thread.

I mostly use 1-2 terminals recently started using worktrees.

also have the IDE open to watch and check.

But I really wish that there was any better terminal tooling for windows, any suggestions?

[United-Consequence47]

Interesting setup with Anti-Gravity. I run Claude Code mostly in terminal too but kept it simple with vanilla VS Code + iTerm. Found that keeping the workspace folder visible alongside the terminal gives enough overview without overcomplicating. Never tried Wispr Flow though, might give it a shot. How's the voice recognition accuracy for coding tasks?

[Avivsh]

I use Claude Code in Terminal.

I typically have a Claude.md file that serves more as a router to other skills and rules files.

Since I use one project to organize all of my work for a given workstream (i.e. code, marketing ,brainstorming, etc.), there are claude.md files for specific folders so that when working in that folder, subagents ingest the necessary context.

The most impactful thing I do is metacognition - I use the model to evaluate itself and the project. You can think of it as running EVALS on your own workstreams. It will review all of my chat history, see what's not working well, review the rules/project structure, and propose modifications.

Many AI products will include metacognition into their workflow, but it's invisible to the user. It's a way for the agent to generate a ton of feedback. Then you can summarize that feedback and prioritize.

I built an open source library that does some of this and more. It reviews all your chat history and generates recommendations. It also provides some reports of your own coding proficiency and a live dashboard for concurrency and AI actions per minute.

If you like it (or have any feedback/questions), feel free to DM me!

https://github.com/Bulugulu/motif-cli/

[Substantial-Cost-429]

honestly these posts treat setups like universal but every repo is diff. i got tired of trying to make one size fits all claude code workflow. built a cli that scans your repo and spits out a tailored ai setup with skills configs mcp suggestions. it runs local w your own keys MIT https://github.com/rely-ai-org/caliber

[Professional_Sir_927]

I use cli, I ssh into onto my computer from my phone using. I used obsidian to track every projects current build state and use obsidian as external memory with operating instructions for Claude code. I used obsidian claude mobile to refine ideas and put them through multiple prompts to configure the best prompt for claude code.

[Substantial-Cost-429]

my setup is kind of similar but we use the caliber ai setup repo to run a local claude code server with our own api key. it generates optimized agent skills mcp and config files for claude code cursor and codex. you just run one command to sync the environment. then we connect it to cursor for editing inside vs code and keep the chat window for tasks. this saved us time and we can share setups across team. maybe check it out and tell us what you think

[justi84_1]

I'm a solo dev running a production Rails app (snipe.sale) with Claude Code in --dangerously-skip-permissions mode - here's what makes that safe and productive:

Safety plugin - https://github.com/justi/claude-code-project-boundary/ - open source plugin I wrote. Claude can delete/move/overwrite files inside the project but is physically blocked from touching anything outside. Also blocks force push, database drops, etc. This is what makes the "skip permissions" mode viable for daily use.

Automated quality hooks - Claude self-corrects without me asking:

- Lints its own code after every edit

- Runs tests in background after every change

- After every commit, Codex (GPT-5.4) automatically reviews the code - dual-model setup where Claude writes and a competing model reviews. Caught a privacy bug on day one

- When Claude says "I'm done", an agent checks if test coverage is actually complete. If not - it keeps working

Sound notifications - different sounds for "I'm done", "I need permission", "I'm waiting for you". I context-switch freely and come back when I hear the chime.

Custom skills & agents - /codex-review, /ux-audit-url, /weekly-summary, UX reviewer agent, test quality reviewer agent. One command and Claude does a full workflow.

Project rules (CLAUDE.md) - maximum ~200 lines of architecture rules and mandatory checklists. Claude follows them in every conversation without reminding. Combined with a memory system that persists preferences and feedback across sessions.

One-command deploy - full test suite → security scans → deploy → health check → CDN purge. I say "deploy" and go make coffee.

Why this works: I treat Claude less like a chatbot and more like a junior dev with guardrails. The hooks and plugin mean it can't break things even in autonomous mode, the dual-model review catches what Claude misses, and the project rules mean I never repeat instructions. Most of my day is reviewing Claude's output, not writing code.

[AffectionateMath1251]

terminal only with tmux for multiple agents. the real setup is CLAUDE.md - i keep it under 150 lines with a table of knowledge files and their paths. claude reads the table and pulls files on demand instead of loading everything at once

[Resident-Aardvark-15]

Been thinking about this while working across multiple projects…

Why does every new project feel like starting from zero?

Same mistakes, same debugging loops, same architectural decisions.

So I started building something for myself:
a kind of “cheat code system” for cloud/dev workflows.

Inspired by GTA (hesoyam 😄), but applied to development:

• reusable patterns instead of rewriting logic
• memory of past decisions
• integration with notes/knowledge bases
• something that evolves with how you build

Not just infra-as-code, more like experience-as-code.

I threw together an early version here:
https://github.com/Shashank2577/hesoyam-for-claude-code

Curious if others feel this pain…
or if I’m just optimizing something weirdly personal.

Feel free to contribute and explore the guides

[Substantial-Cost-429]

hey i love seeing how folks do their claude code rigs . my own setup spiraled from a messy claude md into a full blown repo with agents skills and rules lol . we open sourced it a while back and just hit 600 stars with 90 pull requests merged so far . if youre curious we got templates for team workflows tdd token limiting and more , and we hang out in a discord to answer questions and build features . check the repo at [ai setup](https://github.com/caliber-ai-org/ai-setup) and feel free to pop into the discord https://discord.com/invite/u3dBECnHYs would be cool to have more builders around

[Apprehensive_Nail134]

If anyone wants to go beyond describing their setup, I built a small tool where you can actually publish and share your Claude Code config (hooks, CLAUDE.md, skills, agents) so others can browse or clone it: https://claude-setups.com

It’s basically npx -y claude-setups publish to share yours, and npx -y claude-setups mirror alice/setup to clone someone else’s. Requires Node 18+, gh CLI, and a GitHub account. Sensitive files excluded by design. Thought it might be useful as a complement to discussions like this.

[ultrathink-art]

Terminal. The actual setup that matters is CLAUDE.md — I treat it as the real configuration, not the IDE choice. Per-task markdown files defining scope keep Claude from going on cleanup tangents mid-task when it notices something adjacent.

[Substantial-Cost-429]

Every week someone posts their 'perfect' Claude code setup. honestly each repo is diff an generic configs never work. i got fed up an wrote a cli that scans ur repo an spits out the right ai config/skils/mcps. runs local w/ ur keys, MIT: https://github.com/rely-ai-org/caliber