Prisma

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

How do you actually use Claude Code properly for building a real full-stack app? (First Reddit post)

Hey everyone, This is actually my first time posting on Reddit, so sorry if I ask this in a weird way. I’m building my first serious commercial SaaS/web app and I’m trying to figure out how to properly use Claude Code for development. The project is a Next.js full-stack app (App Router + TypeScript + Supabase + Prisma + Stripe + Upstash + some AI integrations). I already have a full architecture/requirements document prepared for it (around 40+ pages covering database, APIs, auth, scaling, security, build order, etc). Additonal Note: this architecture plan and all thinking i got from claude. let me know if the architecture is good as well My issue is this: I have Claude Pro, but I honestly don’t know how people are using Claude Code to build full products. I’ve only used: Claude web VS Code extension That’s it. What I don’t understand is: How do you structure a project with Claude Code from day 1? Do you feed it your whole tech doc and let it guide you? How do you avoid making a mess later when scaling? How to develop UI to match my brand and not look AI at all How do you use it properly for architecture decisions instead of just generating random code? How do you make sure security is handled right? How do you manage context across a big project? How do you know when to trust it vs when to manually think? This isn’t just a small side project. I want this to become a real commercial product, so I want to build it the right way from the start (scalable, secure, maintainable). I feel like I’m missing the “workflow” part. Like: How do experienced devs actually use Claude Code as a real development partner? Also if anyone knows: Good FREE courses for learning this workflow YouTube channels/tutorials specifically about building real products with Claude Code (not just toy apps) Resources on AI-assisted software engineering / AI-first development please drop them. I’m not really asking if my app is doable — I know it is. I’m asking how to learn to build it properly with Claude as part of my workflow. Would appreciate real advice from people who’ve actually shipped stuff this way. submitted by /u/Chance_Block_5726 [link] [comments]

Fable 5 with Ultracode on a PR Review

I'm only on $20 pro plan, after switching from $200 plan back when Opus 4.6 was king. At some point we were given credits equal to our plan so I have had a lot of extra usage credits sitting around that I will dip in to every now and then. It helps when you want Opus 4.8 to finish a task without waiting for hours for the window refresh and I can normally only do 1 task before I hit the window... my repo is pretty big and the tasks I get it to aren't normally trivial. So when Fable 5 is released I thought I'd give it a PR that was (in my mind) pretty much ready to merge and put it on "ultracode" to get the full experience. I used the "/pr-review" skill, told it to automatically fix anything that scored 50 or more (I find the default >75 pretty limiting on what it actually fixes). Now this PR is not a normal one, it's turned into a behemoth because it includes an entire Discord bot. It contains 22k lines of new code. I realise this is not best practice but I thought it was a cool way to see how good Fable is. Within minutes I blew past the 5 hour window. It ended up using a total of £63.12 in extra usage. PR #315 is reviewed, fixed, and pushed. The multi-agent review (10 reviewers across bugs/security/CLAUDE.md/architecture/quality, each finding independently confidence-scored) surfaced 63 raw findings that collapsed to 38 distinct issues scoring 50+. I fixed 35 of them, pushed commit 3dbc4e92 to the PR branch, and posted both comments: Very impressive! Just also... very expensive 😄 Fable ensured CI/CD pipeline was clean, PR was green.. all tests passed, no typescript errors etc. It even left a few things for me to opine on: Three things I deliberately left for you (flagged in both comments): the bot writing XP directly to the shared DB via Prisma (relocating it behind internal API endpoints is a real architectural refactor), the missing spec-mandated triage buttons / /staff subcommand handlers (feature scope, looks like deliberate v1 deferral), and splitting the 939-line discordServerSetup.ts (pure churn, your call). I also verified four findings as intentional and excluded them — notably ManageThreads (added deliberately in ace825ed) and the requestLogger originalUrl change (it fixes racy sub-router path logging, not a regression). Maybe it's time to come back to the $200 plan but what it actually shows I think is just how important it's going to be in future to choose the right model for each job. Fable ultracode thinking every PR is going to get expensive, fast! submitted by /u/oddslol [link] [comments]

Autonomous Claude Code loop running my open-source app 24/7 - triages, codes, merges itself. Let's see how far this goes!

Hey r/ClaudeAI, I want to share a project that's really two things at once. The product: GymCoach is an open-source, self-hosted hypertrophy training tracker with a built-in AI coach. Next.js 14 + TypeScript, Prisma/Postgres, Docker. The coach builds a compact, structured payload from your profile, recent sessions, active program and per-exercise progression - then suggests program changes that are Zod-validated before anything touches your data. Provider-agnostic LLM layer (Anthropic / OpenRouter / a keyless demo mode), so you can run it however you want. The actual experiment: this is a deliberate test of the limits — I'm letting the repo run itself and seeing how far an autonomous loop can take a real codebase before it breaks, stalls, or surprises me. There are autonomous Claude Code loops that: - triage the codebase for real work (TODOs, coverage gaps, small bugs, roadmap items) and file scoped GitHub issues, - implement an issue end-to-end on its own branch, following the repo's conventions, - pass a hard "green-gate" (lint + typecheck + unit + build, integration/E2E in CI) before anything merges, - ship the PR — wait for CI, self-review the diff, auto-merge on green, - then write up what shipped in the changelog and a public playbook. So the issue → PR → review → merge → document cycle closes without me in the middle. Every merged change has to earn its way past the same gate a human contributor would. The whole "how it maintains itself" démarche is documented in the repo so it's reproducible, not just a demo. The open question: I genuinely don't know where this goes - that's the point of pushing the limits. Does the loop grind toward becoming the most advanced open-source fitness-tracking repo out there? Or does it quietly pivot on its own into something I didn't plan? We'll see how far it can go. And I keep adding new loops to feed the self-improvement - like a deep-research loop that scouts new feature ideas, benchmarks against competing apps, and mines the public reviews of other fitness apps to turn real user pain points into issues the build loop can pick up. Follow along (issues, PRs, changelog all public): github.com/Julien-Au/gymcoach Happy to answer questions about the loop setup, the green-gate, or how the AI coach payload is built. submitted by /u/Newbie_investisseur [link] [comments]

Claude Code drifts off the architecture I set by session 3. Anthropic has a name for it: “agentic technical debt.” Here’s the ritual that fixed it for me.

If you've shipped anything real with Claude Code (or Cursor, or Cline), this pattern will be familiar. The first session feels unfair, the code just appears. Around session 3 the agent quietly picks a different architecture than the one you agreed on. By session 7 you've got the same feature built two ways and no clear answer on which is correct. I spent months assuming the fault was mine, with maybe a little blame on the model. Then I ran into the term in Anthropic's founder playbook: agentic technical debt. What made it click was the contrast they draw. Normal tech debt holds still, and you can pay it down in one focused pass. The agentic kind keeps compounding. If your specs and decisions aren't written somewhere the agent reads before it acts, every session re-derives the foundation from zero, and those derivations drift apart. Enough sessions in, there's no single mental model under the code. Each part runs fine on its own. They were just never designed to live together. For a while I read that as a skill problem on my end. That was the wrong read. The agent is good enough to rebuild your architecture by itself, and there's nothing keeping it tied to the one you chose. It reads the repo, writes the feature, runs the tests, all without supervision. It works at full speed, which means it drifts at full speed. By session 3 you've got a Frankenstein, and you got there faster than you ever could before. Better prompts didn't fix it. Strapping memory onto it didn't fix it. What worked was a routine that keeps the agent on the architecture I chose, session after session. Before someone brings it up: yes, the memory tooling exists now (memory MCPs, session memory). It genuinely helps. But it solves recall, not direction. An agent can recall every prior session and still walk straight off the plan. Remembering a decision and being bound to it aren't the same problem, and right now only the first one has real tooling. Here's the unglamorous version that actually worked, after a lot of breaking and patching: Write the decisions before you write code. Ahead of session one I put it all down: the business model, a PRD that spells out what's in scope and what's explicitly not, the DB schema described in plain words, the system architecture, and a CLAUDE.md holding the non-negotiable rules the agent reads each time. The out-of-scope list punches above its weight. It's the thing that keeps the agent from "helpfully" rebuilding something a week later. Split every session into three phases. Phase 0, the agent reads the docs. Phase 1, it checks the scope and raises anything that clashes with what's already settled. Phase 2, it builds only the declared scope, and I review at the end through the branch's commits. Break the sequence and it starts wandering again. Log every real decision as an ADR: context, decision, rationale, rejected alternatives. Next time around the agent reads the ADR instead of reopening something you already closed. No single habit gave me more back than this one. Push the rules into something deterministic wherever you can. A doc that says "validate every input" is a suggestion; a failing test says the same thing and the agent can't argue with it. Linting, type-checks, a test going red, a pre-commit hook, none of those get reopened, because they aren't up for debate. The docs point the direction. These are the wall that stops the agent from drifting off it once the context gets tight. Curious how the rest of you deal with this. Do you keep an ADR log? Does your CLAUDE.md last more than a week, or is it rotting by Friday? What's the session routine that actually holds up for you? What do you enforce mechanically, and what do you leave to the doc? Se submitted by /u/pauloeduardomc [link] [comments]

How long would a project like this take realistically?

I’m trying to calibrate my expectations as a developer building with Claude / AI coding tools and managed services. How long would it realistically take to build a system with the following scope? * user authentication + onboarding * AI persona configuration (behavior, tone, constraints) * uploading and processing user knowledge (PDFs, text, YouTube video transcripts via links) * RAG-based chat system over that knowledge * voice cloning via third-party APIs * voice-based interaction with the AI (speech-to-speech flow) * integrations with external social media platforms where the AI can respond on behalf of users * background jobs + orchestration between components Assuming heavy use of Claude for coding assistance and existing APIs/services (e.g., ElevenLabs + Composio), what would be a realistic timeline for a single developer to bring something like this to a usable level? For context I'm a junior dev this is not a personal side project, it's a company work project I work full time + around 2 hours overtime They gave me a 2 days then extend it to 3 days deadline what they want it to see the most is a decent quality of voice cloning / voice chat, AI persona configuration and RAG-Based chat. it's typeScript monorepo with Next.js frontend, NestJS backend, Prisma/PostgreSQL + pgvector submitted by /u/AppropriateLeading6 [link] [comments]

What I learned shipping production code with Claude Code (beyond 'build me a SaaS')

Most people drive Claude Code like a slot machine: "build me a SaaS that makes money," hit enter, hope. You get a demo that looks great and collapses the moment it meets real traffic — usually with zero security and no idea how its own database works. After a lot of sessions, the thing that changed my output wasn't a better prompt, it was treating Claude Code as something I drive, not something I delegate to blindly: Memory architecture. I keep instruction files (CLAUDE.md / .cursor/rules) so the agent shares my conventions across sessions instead of re-deciding the stack every time. This alone killed most of the "it rewrote half my app" chaos. Verification discipline. The agent proposes, I verify — types, tests, a Lighthouse check — before anything gets committed. Claude is great at generating; it's terrible at being trusted unsupervised. MCP servers to give it real context (DB schema, my own docs) instead of letting it hallucinate the shape of my data. Scoping the task small. "Add this one endpoint with these constraints" ships. "Build the platform" wanders. Where it got interesting: once Claude Code stopped fighting me, I used it to actually build and self-host a proper stack — Hetzner VPS + Ploi, MySQL + Prisma, MinIO for S3-style storage, the whole environment in one Docker Compose file. The agent can absolutely help you stand that up if you give it the architecture and verify each step. The lesson: vibe coding shouldn't mean shipping something that gets hacked day one. Claude Code is a sharp tool — it just needs a driver with a workflow that respects SEO, security, and scalability. Happy to go into the memory setup or the verification loop if anyone wants specifics. (I also wrote longer notes on my site, but the meat is above.) submitted by /u/Silly_Subject_5199 [link] [comments]

I built a local context compiler so AI coding agents stop re-reading the same repo

I’ve been working on an open-source tool called Madar. The problem I kept running into with AI coding agents is that they often rediscover the same codebase again and again. They grep, read files, summarize, lose context, then repeat the same exploration in the next task. On larger TypeScript/Node.js repos, this becomes slow, noisy, and expensive in tokens. Madar tries to solve this by acting as a local context compiler. It builds a structural graph of your codebase, then compiles compact context packs for a specific task before the agent starts broad repo exploration. The idea is not to replace file search. It is to give the agent a better starting point: relevant files/symbols route/service/call relationships runtime execution slices source locations coverage/missing-context diagnostics compact prompts for agents It works locally and does not require an API key to build the graph. Current support is strongest for TypeScript/Node.js projects, with framework-aware extraction for things like NestJS, Next.js, Express, Fastify, Hono, tRPC, Prisma, and routing-controllers. It can be used through MCP with tools like Claude Code, Cursor, Copilot, and Gemini, or through CLI-generated prompts for tools like Codex, Aider, and OpenCode. The package was previously called graphify-ts, but I renamed it to: @lubab/madar Install: npm install -g @lubab/madar Basic usage: madar generate . --spi madar summary madar pack "how does auth work?" --task explain madar claude install I’ve also been testing it with native-agent benchmarks. In some real backend prompts, it reduced provider-reported input tokens significantly. I’m being careful with that claim because results depend heavily on the repo and task, but the direction is promising. What I’m trying to validate now: Is “context compilation” a useful layer for AI coding agents? Do execution slices make codebase explanations more reliable? Can we reduce token waste without hurting answer quality? What benchmark format would developers actually trust? GitHub: https://github.com/mohanagy/madar npm: https://www.npmjs.com/package/@lubab/madar I’d genuinely appreciate technical feedback, especially from people using Claude Code, Cursor, Copilot, Codex, Aider, or other coding agents on larger repos. submitted by /u/CaptainProud4703 [link] [comments]

I learned something tough today

Turns out Claude is aware of the fact that I don't know how to make friends. submitted by /u/enfarious [link] [comments]

My pre-coding routine with Claude Code, 5 MCP servers before I write a single line

Been running this routine for months now. Started because I was losing too much time to Claude just guessing. Halluzinated class names, outdated SDK methods, advice that didn't match the codebase I was actually in. So I built a routine I run before I let it write anything. Takes maybe 60-90 seconds. Saved me hundreds of hours by now. Start the session and load memory. A memory MCP carries context across sessions. Last sprint, open decisions, recent learnings, why we picked X over Y three months ago. Without this, every session starts cold and Claude rebuilds my reasoning from scratch, usually wrong. Index the codebase as a graph. A codebase-memory server builds a knowledge graph of the repo. Functions, callers, dependencies, cycles. When Claude needs to know what calls processOrder, it queries the graph instead of grepping blind. One tool call replaces dozens of file reads. Search with Tavily for current practice. Before any non-trivial decision I let it search what people are actually doing right now. Training data is old. Best practices from a year ago aren't always still best practices. Clean answer with sources, not a wall of SEO spam. Load Context7 for library docs. Context7 fetches current docs for whatever library I'm about to touch. Anthropic SDK, Next.js, Prisma, whatever. The training cutoff means the model cheerfully invents API methods that got renamed two versions ago. Loading the actual current docs ended that whole category of bug months ago. Now write code. At this point Claude has memory, codebase structure, current ecosystem context, and accurate library docs. The output is dramatically different. Less "let me try this and see", more "based on the call graph and the v5 docs, the change goes here". Hooks are the other piece nobody talks about. The single most important one for me is a read-before-edit guard. It refuses any edit on a file the session hasn't actually read first. Yes, it costs extra tokens up front because the model has to load the file properly instead of guessing what's in it. Those extra tokens are nothing compared to the tokens you burn cleaning up edits that were made blind. Same idea with a safety guard that blocks destructive commands, and a hook that triggers a re-index after edits so the graph stays in sync. And then the loop closes. Whatever worked goes back into memory. Decisions, patterns, traps we hit, fixes that stuck. Next session starts with all of that already loaded. The system gets sharper every week, not because the model changed, but because the context around it keeps compounding. The bigger pattern I figured out over the past few months is that I stopped treating the model as the source of knowledge. The model is the orchestrator. The MCP servers and the hooks are the system. Memory remembers, the graph knows the code, search knows the present, Context7 knows the docs, hooks keep the model honest. The model just connects them. Curious what other people stack before they start a session. Anyone doing this with different servers or hooks? submitted by /u/studiomeyer_io [link] [comments]

I built Toolbrew — 10 tools for Claude Code (6 slash commands, 3 skills, 1 hook)

I've been using Claude Code for months and kept hitting the same friction: great first draft, shaky follow-through. Commit messages in the wrong style for the repo. PR descriptions that ignore the template. Test files in the wrong framework. Doc drift. Migrations that don't match my ORM's naming. I'd fix the same things manually every time. So I built a pack. 10 tools. Slash commands: /commit — writes a message in the repo's existing style. Detects Conventional Commits, ticket prefixes, gitmoji, or freestyle. Refuses to bundle unrelated changes. /pr — drafts PR description from the branch diff, fills the repo's PR template if one exists. Flags migrations, breaking changes, new env vars. /review — six-pass review: correctness, contract, failure modes, security, performance, maintainability. Findings ranked blocker / important / nit. /security — OWASP-tagged security-only review. Injection, auth bypass, crypto failures, SSRF, path traversal, leaked secrets. /test — generates tests in your framework (jest, vitest, pytest, go test, rspec, PHPUnit) matching existing naming. /refactor — plans a refactor as small safe steps. Each step leaves tests green. Planning only, never edits. Skills (auto-trigger): docs-updater — when code changes break docs, updates READMEs, doc comments, OpenAPI specs, CHANGELOG. migration-writer — turns a schema change into a correctly-named migration. Prisma / Drizzle / Alembic / Django / Rails. Guards destructive ops with expand-contract. test-fixer — diagnoses why a test failed, decides whether code or test is wrong, fixes the right one. Never silences, never skips, never loosens assertions. Hook: toolbrew-secret-scanner — fires before git commit, scans the staged diff for API keys, tokens, private keys. Blocks if found. Allowlist marker for test fixtures. One leaked PAT is a worse day than any time these tools save. All plain Markdown. Read them, tune them, fork them. If Toolbrew stops suiting you, delete four folders and you're out. Install: ./install.sh (macOS/Linux) or .\install.ps1 (Windows). Copies to ~/.claude/. Nothing calls home. No telemetry. What this is NOT: not a service, not a cloud wrapper, not subscriptionware. Buy once, own the files, run locally. https://toolbrew.app Happy to answer anything. If a command feels off, the fix is usually one file edit — genuinely curious what people hit. submitted by /u/ultrapreci [link] [comments]

Got into Anthropic's Opus 4.7 hackathon — pushing Verified Skill (security + evals + package manager for AI agent skills, 49 platforms) this week

Approved at 1:39 AM this morning. 500 builders, $100K pool, virtual, judges from the Claude Code team. Apr 21-28. The product (already shipping, this week I push harder) Verified Skill is what every AI agent ecosystem is missing: security + quality + distribution for AI skills. Security — skills execute code, touch your tools, read your files. 52 known attack patterns. We scan and grade every skill 3 tiers (Scanned / Verified / Certified) before install. Quality — Skill Studio (npx vskill studio) is a 100% local eval framework. Plain-English test cases. A/B vs baseline. Multi-model (Claude, GPT, Gemini, Llama, Ollama). Nothing similar exists for AI skills today. Distribution — vskill CLI. Universal package manager. Works across 49 agent platforms (Claude Code, Cursor, Copilot, Windsurf, Codex, Gemini CLI, Cline, Aider, and more). The bet Every agent platform runs SKILL.md now. The question isn't "which format wins" — it has. The question is who builds the infrastructure around it. This week with Opus 4.7 Agent-aware generation: one skill source → tailored outputs per agent Smarter routing based on target-agent capabilities Tighter eval loops Daily ships Stack: Node.js ESM CLI, Cloudflare Workers + D1 + Prisma, Next.js 15 dashboard. Orchestrated through SpecWeave — my spec-driven dev framework (open source): https://spec-weave.com Links - Verified Skill: https://verified-skill.com - SpecWeave: https://spec-weave.com Swap notes Anyone else in the cohort? Anyone shipping developer tooling who wants to compare notes this week? submitted by /u/OwenAnton84 [link] [comments]

Building a personal training coach app — looking for stack advice and alternatives

I'm a freelance developer and I just got a new project: a personal training coach app. The idea is a Flutter mobile app for clients (iOS + Android) and a private Next.js web dashboard for the coach to manage everything. Looking to see if anyone has built something similar or has thoughts on the stack I'm planning. --- Quick background on my previous work** I've shipped a full ecommerce platform for a supplement store (Flutter app + Next.js site + employee dashboard + owner dashboard, all sharing one NestJS backend), and a dental clinic app (Flutter + NestJS + Supabase). Both are in final review with the clients right now. This coach app would follow a similar architecture. --- What the app needs to do Coach side (web dashboard): build workout programs organized by muscle group, assign them per client, manage a custom exercise library where each exercise has a recorded video demo attached, track client progress (weight, measurements, progress photos), review weekly client check-ins, send meal plans, 1-on-1 messaging with clients, and manual payment tracking. Client side (Flutter app): guided workout sessions set by set with rest timer and video demos, workout logging, weight and measurement tracking with charts, progress photo uploads, meal plan viewer, weekly check-in forms, in-app messaging with the coach, push notifications. A few features I'm particularly happy with: -Equipment-aware program builder— when building a program for a client, the dashboard warns the coach if he tries to assign an exercise that uses equipment the client's gym doesn't have. Clients fill a gym equipment checklist on signup. - Training split assignment — coach sets the split (PPL / Upper-Lower / Bro Split / Full Body), the calendar auto-structures itself around it. - Full intake form on signup — before the coach even accepts a client, they fill stats, goals, experience, available days, preferred split, gym equipment, injuries, and progress photos. --- Stack I'm planning - Mobile: Flutter + Riverpod, Feature-First architecture - Backend: NestJS + PostgreSQL via Supabase, Prisma ORM - Dashboard: Next.js 14 App Router + TailwindCSS - Auth: Supabase Auth — TOTP 2FA for the coach, OTP for clients - Chat: Stream Chat (1-on-1 real-time messaging) - Push:OneSignal - Storage:Supabase Storage — private buckets for progress photos - Videos: Coach records each exercise demo himself, uploads as unlisted YouTube videos, pastes the link into the dashboard. Plays inline in the app. No video hosting cost. - Cache:Upstash Redis - Hosting: Railway For the videos specifically — I went with unlisted YouTube instead of direct upload because hosting video is expensive and YouTube handles delivery well. Coach records his own demos so everything feels personal, not generic. Open to other approaches here. **How I'm building it:** Claude Sonnet 4.6 via Claude.ai for architecture decisions and structured agent prompts (using Claude's built-in skills for systematic debugging and security auditing), then pasting into Antigravity as my IDE instead of Claude Code. --- What I'm actually asking - Has anyone built a similar coaching/training app? What did you use and what would you do differently? - Any better alternatives to Stream Chat for 1-on-1 coaching messaging at this scale? - For the video demos — is unlisted YouTube the right call or is there a better approach? - Any obvious gaps in the feature set for a personal training app like this? Appreciate any input. submitted by /u/Cowboy_The_Devil [link] [comments]

I thought my agent needed a better prompt. It actually needed a better loop

I rebuilt part of my agent loop this week and it changed how I think about prompt engineering. My old assumption was that when an agent kept messing something up, the fix was probably to add another instruction. What I’m starting to think instead is that a lot of the leverage is in improving the reusable workflow around the agent, not making the prompt longer. Concrete example: I had a loop where an evaluator would check a feature, the orchestrator would read the result, and if it got a PASS the issue would get marked done. That sounded fine until I noticed a feature had been marked complete even though it was missing a Prisma migration file, so it wasn’t actually deployable. The evaluator had basically already said so in its follow-up notes. The problem was that the loop treated “PASS, but here are some important follow-ups” too similarly to “this is actually ready to ship.” So the issue wasn’t really the model. It was the workflow around the model. I changed the loop so there’s now a release gate that scans evaluator output for blocking language. Stuff like: must generate cannot ship before any live DB blocking If that language is there, it doesn’t matter that the evaluator technically passed. The work is blocked. The other useful piece was adding a separate pass that looks for repeated failure patterns across runs. What surprised me is that this did not mostly suggest adding more instructions. In a few cases, yes, a missing rule was the problem. Example: schema changes without migrations. But in other cases, the right move was either: do nothing, because the evaluator already catches it or treat it as cleanup debt, not a workflow problem That distinction seems pretty important. If every failure turns into another paragraph in the template, the whole system gets bigger and uglier over time. More tokens, more clutter, more half-conflicting rules. If you only change the workflow when a pattern actually repeats and actually belongs in the process, the system stays much leaner. So I think the useful loop is something like: run the agent evaluate in a structured way block release on actual blocker language look for repeated failure patterns only then decide whether the workflow needs to change The main thing I’m taking away is that better agents might come less from giant prompts and more from better “skills” / command flows / guardrails around repeated tasks. Also, shorter templates seem better for quality anyway. Not just cost. Models tend to handle a few clear rules better than a big pile of accumulated warnings. But you only get there from observations and self-improvement. Curious whether other people building this stuff have run into the same thing. submitted by /u/NovaHokie1998 [link] [comments]

I built Klonode — an auto-generated routing graph so Claude Code only loads the files a task actually needs

On a 500-file monorepo every Claude Code conversation was burning through context loading stuff it never touched. I got tired of hand-maintaining CLAUDE.md and shipped a tool that does it automatically. **Klonode** scans your repo, writes one `CONTEXT.md` per directory and a root `CLAUDE.md` routing graph, and at query time picks the few folders that actually matter. It's a 5-layer model (root → domain → stage → reference → artifact) with a SvelteKit workstation on top — tree view, reactive graph view with routing heatmaps, multi-session chat panel that streams Claude CLI output, and a CONTEXT.md editor with injection-risk badges for anything extracted from your source files. Shipped this week: - TS/JS, Svelte, Python, Java, Ruby, Prisma, GraphQL, SQL extractors - Framework detection for Next.js, SvelteKit, Astro, Deno, Bun, Turbo, Prisma - Full prompt-injection hardening pipeline (sanitizer → scanner → UI trust badges) - Self-introspection API: components self-describe so the CLI can query workstation state without taking screenshots Where I need help: - Extractors for **Go, Rust, PHP, C#, Kotlin** — each is ~30 LOC, one regex block. [PR #13](https://github.com/smorchj/klonode/pull/13) is the 104-line template for Python/Java/Ruby. - Framework detectors for **Rails, Django, FastAPI, Remix, SolidJS, Qwik**. - People with real codebases in those stacks to try it on and tell me what breaks. Good-first-issue tracker: https://github.com/smorchj/klonode/issues/56 Repo: https://github.com/smorchj/klonode Early alpha. Feedback welcome — especially "this broke on my repo because…" submitted by /u/awallofburrito [link] [comments]

Save 500K+ credits per week: the 4300-word prompt that kills 90% of my production bugs before they're written.

Claude Code's plan mode looks thorough, but the plan it creates always have repeat blind spots that ship as production bugs. I wrote a one-shot self-review prompt you paste AFTER Claude drafts its plan. It forces Claude to walk every layer of the stack (build, routing, UI, hooks, API, DB, security, deploy, etc.) and answer "is this handled? what about that edge case?" before any code is written. Ends with a forced summary so the important risks land at the top where you can actually act on them. Full prompt at the bottom. It's long. That's the point. The problem You ask Claude Code for a feature in plan mode. It drafts a tidy 7-bullet plan. Looks complete. You approve. It writes the code. type-check is green, your local dev server works, you push. Prod breaks in a corner nobody thought about. After shipping ~30 features this way I started keeping a list of what was biting me. It was embarrassingly repetitive. Every one of these shipped from a plan Claude and I both looked at and said "yeah that's fine": tsc --noEmit passed but next build blew up on a server-only module (nodemailer, node:crypto, geoip-lite) leaking into the client bundle via a barrel file Feature worked in my personal workspace but broke in team workspaces because the query wasn't scoped to workspace_id Double-click created two DB rows because there was no idempotency key New page had no loading.tsx or error.tsx, so the default Next.js fallback rendered for users Middleware regression because the new public route wasn't added to the public matcher Race condition because the limit check happened BEFORE the insert instead of in the same transaction, so two concurrent submits both passed the check React hooks ordering bug: someone put an early return above a useEffect in the public renderer, and every published page crashed with React Error #310 Controlled input anti-pattern: the was bound directly to server state, and backspace got eaten on slow networks because the debounce re hydrated mid-keystroke process.env.X used directly instead of going through the env validator, so prod crashed on startup because the validator never ran New form field type added to the editor but not to the public renderer switch, so published pages crashed for that type Every single one was catchable at planning time. Claude just wasn't being asked the right questions. The fix I wrote a self-review prompt I paste after Claude drafts a plan. It's big. ~500 lines of "answer every single one of these questions about your plan." Each section is a layer of the stack. Each individual question is a real bug I've shipped at least once. The workflow: Enter plan mode in Claude Code Describe the feature you want Claude drafts its plan You paste the stress-test prompt (below) as your NEXT message Claude walks every section, flags N/A on ones that don't apply, and adds missing pieces to the plan as it goes Claude ends with a forced ✅/⚠️ /🚫/💣 summary: ✅ READY: parts of the plan that are fully defined and buildable ⚠️ ADDED: things missing from the original plan that the stress-test just added 🚫 NEEDS MY INPUT: open questions that need your answer before code is written 💣 RISK WATCHLIST: top 3 things most likely to break in prod for THIS specific feature and what would catch them You review the four buckets, answer the 🚫 questions, THEN approve the plan The forced summary at the end is the real trick. Without it, Claude buries the important stuff 2000 tokens deep in the self-review and nobody scrolls that far. With it, the risks and gaps land at the top where you can actually act on them. Results Over ~65 features since I started using this: the bug classes in the list above basically stopped shipping. What I still ship are things genuinely unknowable from the plan (a weird Stripe webhook ordering edge case, a user doing something I never considered, a 3rd-party API returning a shape it's never returned before). The "this was obvious in hindsight" bugs are gone. Rough guess: went from 8-10 production regressions a month to maybe 3 to 4 every couple months. Honestly the plan I end up with is also better than what I would have written by hand. I have been doing this for almost a year and the stress-test catches things I forget because I'm tired or distracted. It's not smarter than me in a peak moment, but it's better than me at my average. Caveats before you paste It's tuned for Next.js 15 + Supabase (self-hosted) + Clerk + Dokploy. Most checks are stack-agnostic but some (RLS blocking the browser client, Clerk token refresh, middleware matcher, Dokploy shallow clones) are specific. Swap in your stack's equivalents. If you use Prisma, rewrite the RLS section. If you use NextAuth, rewrite the Clerk section. If you don't use Dokploy, drop the deploy-platform specifics. It's long on purpose. Short self-review prompts miss things. The cost of Claude saying "N/A" to 40 irrelevant questions is nothing. The cost of one