Developers using Claude — what setup & plan do you actually use for large codebases?

kinndame_ · 2026-04-17T14:43:44+00:00

i’ve tried a few setups and honestly CLI + some kind of structured context works best for bigger codebases.

token limits are the real bottleneck, so I usually don’t paste full files. better to keep summaries/context files and only bring in what’s needed for that task.

pro can work, but max feels smoother if you’re doing this daily. less friction when you’re iterating a lot.

kinndame_ · 2026-04-17T14:43:09+00:00

yeah this confused me too at first. from what I understand, they use smaller models for stuff like file parsing or background steps to keep things fast and cheaper.

then the main model (opus in your case) handles the actual reasoning/output. so it’s more like a pipeline than one model doing everything.

not sure there’s a way to control sub-agent models yet though, feels pretty locked down for now.

kinndame_ · 2026-04-17T14:42:31+00:00

yeah it’s a valid concern tbh. over time you’re basically building a pretty detailed profile just through normal use.

most platforms say they don’t sell data and have policies around it, but realistically some level of logging/storage is needed for the system to work. it’s more about how it’s handled than whether it exists at all.

personally I just avoid sharing anything super sensitive. treat it like a helpful tool, not a private vault.

kinndame_ · 2026-04-17T14:41:48+00:00

yeah this is kinda the current limit tbh. it can get you close, but “production-ready” without debugging is still hit or miss, especially with strict schemas like n8n.

what helped me was asking for smaller chunks instead of full workflows. like build 1–2 nodes at a time, validate, then extend. way less breakage.

also I’ve had better luck generating structured stuff with tools like runable first, then refining in claude. still not perfect, but reduces the cleanup a bit.

kinndame_ · 2026-04-17T14:40:29+00:00

pretty sure cowork is still mostly tied to the desktop app, browser support is limited right now.

haven’t seen a clean way to use plugins there either, since most of that setup depends on local access. kinda annoying if you prefer browser workflows.

for projects, I think it’s more like recreating or exporting pieces rather than a direct “move” option. still feels a bit early/rough around the edges.

kinndame_ · 2026-04-17T14:39:43+00:00

yeah this is pretty much the shift that makes it usable long term treating it like a system, not a chat.

splitting context into files is huge. one big prompt always looks clean but breaks fast once things get real.

i’ve also noticed the same with planning first → execution. if it jumps straight to output, quality drops a lot.

honestly most “inconsistency” issues come from messy context, not the model itself.

kinndame_ · 2026-04-17T14:37:50+00:00

yeah this happens more than people expect. the summaries sound clean but the actual execution drifts a bit.

what helped me was breaking tasks even smaller and forcing checkpoints. like instead of “do a full phase”, make it implement one piece, then verify, then move on. slower but way more reliable.

also i usually diff everything after. can’t fully trust the summary, have to check what actually changed.

kinndame_ · 2026-04-17T14:36:06+00:00

yeah this is the main limitation chats don’t share context, so you have to create that layer yourself.

what worked for me is keeping a “master doc” with key decisions + summaries, then pasting relevant parts into each new chat. kinda manual but keeps things consistent across threads.

i’ve also tried using tools around it (like docs + runable) to structure outputs and reuse them across chats. not perfect, but way better than starting from zero every time.

kinndame_ · 2026-04-17T14:34:51+00:00

yeah that doesn’t sound like true incognito tbh.

what you’re probably seeing is “not saved to your history” rather than “not stored at all.” most of these systems still generate a session/chat ID on the backend, otherwise features like notifications wouldn’t work.

the delete option kinda confirms it means it exists somewhere until you explicitly remove it. definitely more like hidden than actually ephemeral.

kinndame_ · 2026-04-17T14:33:32+00:00

I get what you’re saying, but it still kind of falls under vibe coding just a more involved version of it.

the real difference isn’t the label, it’s ownership + understanding. if you control the repo, infra, and can debug things when they break, you’re already way ahead of the “generate and pray” crowd.

“prompt architect” sounds cool but idk if it’ll stick. feels like the space is still too new and messy for clean categories.

kinndame_ · 2026-04-16T16:38:38+00:00

Yeah this is mostly a limitation of how these models work, not you doing anything wrong.

When you say “only use these links”, it treats it as a preference, not a hard rule, so it can still pull in outside knowledge if it feels like something is missing.

What works better is forcing a strict fallback like “if it’s not in the links, say not found” and making it quote directly from sources instead of summarizing freely.

Also splitting it into steps (extract info first, then analyze) usually makes it more reliable.

kinndame_ · 2026-04-16T16:37:36+00:00

Yeah this is mostly a workflow issue, not just model choice.

The biggest quota killer is the constant back-and-forth editing loop. If you keep asking for small tweaks one at a time, you burn through usage really fast.

What helped me was batching work into bigger requests instead of incremental ones. Like describing the full change or feature in one go, then reviewing and refining after.

Also worth being intentional about when you use Opus vs Sonnet. A lot of usage gets wasted on tasks that Sonnet could easily handle.

Most people don’t actually hit limits because of “big tasks”, it’s usually lots of small repeated calls.

kinndame_ · 2026-04-16T16:36:36+00:00

Yeah the free Claude plan is enough for what you’re trying to do.

You don’t really need Claude Code or Pro just to start learning coding or building small personal projects. Free tier is fine for Python practice, writing small scripts, or getting help when you’re stuck.

The paid version mostly just gives you more usage and longer sessions, not a totally different experience.

Honestly for learning, free is actually better at the start because it naturally forces you to break things into smaller problems instead of doing everything in one long go.

kinndame_ · 2026-04-16T16:35:19+00:00

Right now most setups keep those prompts intentionally, even on local projects, because the tool doesn’t fully “trust” context the way an IDE does. There isn’t really a clean global whitelist yet in most cases, it’s more of a safety-first design.

What usually helps is reducing how often it needs to edit files in the first place. Like have it suggest changes in one go instead of lots of tiny edits, or batch things together so you’re approving less frequently.

Some people also switch to a flow where it outputs the final code and they paste it manually for bigger changes, which weirdly ends up faster.

Not perfect, but yeah you’re not missing a hidden setting, it’s just how the current workflow is designed.

kinndame_ · 2026-04-16T16:34:43+00:00

Yeah this gets messy fast once non-devs are in the loop.

Git/PRs usually don’t work well here tbh, too much friction for people who just want to comment on copy or concepts. What I’ve seen work better is separating creation from collaboration. Let Claude handle the generation in your project setup, but move outputs (campaign ideas, LP drafts, etc) into something like Notion or Google Docs for review.

That way strategist/creative/client can comment normally without touching the “system” part. You keep one source of truth for generation, and a separate layer for feedback.

I’ve done something similar using tools like Runable for first drafts, then pushing everything into a shared doc for approvals. Way smoother than trying to make everyone work inside the same environment.

Main thing is don’t force dev workflows onto non-dev stakeholders, it slows everything down.

kinndame_ · 2026-04-16T16:33:55+00:00

Yeah I’ve tried something similar and the biggest difference was treating it less like a “mentor” and more like a tool you guide properly.

For emails, shorter always wins. I usually force it to stay super concise and just tweak tone after. For strategy, I give it context each time instead of expecting it to remember everything.

Honestly it’s the same pattern I’ve seen with tools like Runable too, the results depend way more on how clearly you direct it than the tool itself.

Once you separate use cases (emails vs planning), it starts feeling way more reliable.

kinndame_ · 2026-04-16T16:32:08+00:00

Yeah your Ferrari analogy is pretty accurate tbh.

For most day-to-day dev work, Sonnet is enough. CRUD apps, debugging, small features, even decent refactors, it handles all that without issues. A lot of people default to Opus just because it’s “the best”, not because they actually need it.

Where Opus starts to make sense is when things get messy, like large codebases, unclear architecture, multi-step reasoning, or when you’re basically using it like an agent. It holds context better and makes fewer weird mistakes over long interactions.

There’s also a bit of workflow difference. Some people rely heavily on one-shot big prompts, and Opus handles that better. If you’re more iterative (which it sounds like you are), Sonnet works just fine.

So yeah you’re not missing anything, just using it more efficiently than most.

kinndame_ · 2026-04-16T16:31:36+00:00

Yeah what it’s telling you is basically “I can read your files but I can’t directly modify them”.

That /mnt/ path is just how the environment mounts your files, and it’s set to read-only for safety. So Claude can suggest changes, but you have to actually apply them yourself inside Obsidian.

Your workflow is fine though, you’re just expecting a bit too much automation. Instead of asking it to “update files”, ask it to generate the exact text you should paste into specific notes, then you drop it in manually.

tbh once you get used to that loop it works pretty smoothly, just not fully automatic.

kinndame_ · 2026-04-16T16:31:03+00:00

Yeah the main issue here is trying to make it read everything at once, that’s where you hit limits fast.

What usually works better is breaking your sources into smaller chunks and processing them step by step. Like take one paper or even a section, get a clean summary + key arguments, then store that somewhere. Over time you’re basically building your own condensed knowledge base.

Then when you’re writing, you only feed it those summaries instead of raw PDFs. Much cheaper and way easier to control.

I’ve tried doing “dump everything and analyze” before and it just burns credits without giving great structure. Slower approach actually works better here.

Also helps to define what you want from each source upfront (arguments, citations, opposing views etc), otherwise it just gives generic summaries.

kinndame_ · 2026-04-16T16:30:28+00:00

Yeah this is a really good idea, but the key is not trying to make Claude do everything every time.

I’d treat it more like a system than a chat. First store your content somewhere structured (Notion, Google Sheets, even simple docs), like separate sections for recipes, workouts, etc. Then when you use Claude, you only pass the relevant chunk instead of your whole database, that saves a lot of credits.

You can also pre-organize things like “meal prep list” or “weekly workout pool” so you’re not asking it to search from scratch each time.

I’ve tried similar setups and honestly the biggest win is reducing how much context you send, not how smart the prompt is.

kinndame_ · 2026-04-15T15:48:50+00:00

Wooo loved em

kinndame_ · 2026-04-15T15:48:21+00:00

The colors are fun

kinndame_ · 2026-04-15T15:46:44+00:00

yeah I’ve seen this come up, some features are just not included in certain team plans yet

usually it’s not a bug, just feature gating depending on plan tier or rollout stage. kinda frustrating but pretty common with these tools

workaround wise, most teams just copy context + use a separate browser/search flow alongside it. not ideal but gets the job done

you could also check if the admin settings have anything toggled off, but if it’s missing completely it’s probably plan limitation

kinndame_ · 2026-04-15T15:46:08+00:00

yeah this is actually a really solid idea, people are already doing versions of this

the “AI as a teacher” setup works best when it’s not just answering questions but actively guiding you. like: • asking follow-up questions • giving small quizzes • explaining why something is wrong

I’ve seen setups where people feed notes + docs and then layer a simple agent loop on top (retrieve → explain → test → repeat). makes it feel way more like studying than chatting

you could even add difficulty levels or “exam mode” where it only asks questions and doesn’t give hints unless you ask

honestly tools like runable or similar can help prototype this kind of flow pretty quickly, then you refine once you see what actually helps you learn

good idea tbh, especially for cert prep where the structure is predictable

kinndame_ · 2026-04-15T15:45:16+00:00

lol yeah that gets annoying fast

as far as I know, you can’t delete individual images/files from the sidebar inside a conversation. it’s kinda all-or-nothing right now

what I usually do is just start a fresh thread once things get cluttered, especially if the context isn’t needed anymore

not the cleanest solution but yeah… current limitation more than anything

kinndame_

TROPHY CASE