Prisma

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

Prisma AI

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

My Claude.md file

This is my Claude.md file, it is the same information for Gemini.md as i use Claude Max and Gemini Ultra. # CLAUDE.md This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. ## Project Overview **Atlas UX** is a full-stack AI receptionist platform for trade businesses (plumbers, salons, HVAC). Lucy answers calls 24/7, books appointments, sends SMS confirmations, and notifies via Slack — for $99/mo. It runs as a web SPA and Electron desktop app, deployed on AWS Lightsail. The project is in Beta with built-in approval workflows and safety guardrails. ## Commands ### Frontend (root directory) ```bash npm run dev # Vite dev server at localhost:5173 npm run build # Production build to ./dist npm run preview # Preview production build npm run electron:dev # Run Electron desktop app npm run electron:build # Build Electron app ``` ### Backend (cd backend/) ```bash npm run dev # tsx watch mode (auto-recompile) npm run build # tsc compile to ./dist npm run start # Start Fastify server (port 8787) npm run worker:engine # Run AI orchestration loop npm run worker:email # Run email sender worker ``` ### Database ```bash docker-compose -f backend/docker-compose.yml up # Local PostgreSQL 16 npx prisma migrate dev # Run migrations npx prisma studio # DB GUI npx prisma db seed # Seed database ``` ### Knowledge Base ```bash cd backend && npm run kb:ingest-agents # Ingest agent docs cd backend && npm run kb:chunk-docs # Chunk KB documents ``` ## Architecture ### Directory Structure - `src/` — React 18 frontend (Vite + TypeScript + Tailwind CSS) - `components/` — Feature components (40+, often 10–70KB each) - `pages/` — Public-facing pages (Landing, Blog, Privacy, Terms, Store) - `lib/` — Client utilities (`api.ts`, `activeTenant.tsx` context) - `core/` — Client-side domain logic (agents, audit, exec, SGL) - `config/` — Email maps, AI personality config - `routes.ts` — All app routes (HashRouter-based) - `backend/src/` — Fastify 5 + TypeScript backend - `routes/` — 30+ route files, all mounted under `/v1` - `core/engine/` — Main AI orchestration engine - `plugins/` — Fastify plugins: `authPlugin`, `tenantPlugin`, `auditPlugin`, `csrfPlugin`, `tenantRateLimit` - `domain/` — Business domain logic (audit, content, ledger) - `services/` — Service layer (`elevenlabs.ts`, `credentialResolver.ts`, etc.) - `tools/` — Tool integrations (Outlook, Slack) - `workers/` — `engineLoop.ts` (ticks every 5s), `emailSender.ts` - `jobs/` — Database-backed job queue - `lib/encryption.ts` — AES-256-GCM encryption for stored credentials - `lib/webSearch.ts` — Multi-provider web search (You.com, Brave, Exa, Tavily, SerpAPI) with randomized rotation - `ai.ts` — AI provider setup (OpenAI, DeepSeek, OpenRouter, Cerebras) - `env.ts` — All environment variable definitions - `backend/prisma/` — Prisma schema (30KB+) and migrations - `electron/` — Electron main process and preload - `Agents/` — Agent configurations and policies - `policies/` — SGL.md (System Governance Language DSL), EXECUTION_CONSTITUTION.md - `workflows/` — Predefined workflow definitions ### Key Architectural Patterns **Multi-Tenancy:** Every DB table has a `tenant_id` FK. The backend's `tenantPlugin` extracts `x-tenant-id` from request headers. **Authentication:** JWT-based via `authPlugin.ts` (HS256, issuer/audience validated). Frontend sends token in Authorization header. Revoked tokens are checked against a `revokedToken` table (fail-closed). Expired revoked tokens are pruned daily. **CSRF Protection:** DB-backed synchronizer token pattern via `csrfPlugin.ts`. Tokens are issued on mutating responses, stored in `oauth_state` with 1-hour TTL, and validated on all state-changing requests. Webhook/callback endpoints are exempt (see `SKIP_PREFIXES` in the plugin). **Audit Trail:** All mutations must be logged to `audit_log` table via `auditPlugin`. Successful GETs and health/polling endpoints are skipped to reduce noise. On DB write failure, audit events fall back to stderr (never lost). Hash chain integrity (SOC 2 CC7.2) via `lib/auditChain.ts`. **Job System:** Async work is queued to the `jobs` DB table (statuses: queued → running → completed/failed). The engine loop picks up jobs periodically. **Engine Loop:** `workers/engineLoop.ts` is a separate Node process that ticks every `ENGINE_TICK_INTERVAL_MS` (default 5000ms). It handles the orchestration of autonomous agent actions. **AI Agents:** Named agents (Atlas=CEO, Binky=CRO, etc.) each have their own email accounts and role definitions. Agent behavior is governed by SGL policies. **Decisions/Approval Workflow:** High-risk actions (recurring charges, spend above `AUTO_SPEND_LIMIT_USD`, risk tier ≥ 2) require a `decision_memo` approval before execution. **Frontend Routing:** Uses `HashRouter` from React Router v7. All routes are defined in `src/routes.ts`. **Code Splitting:** Vite config splits chunks into `react-vendor`, `router`, `ui-vendor`, `charts`. **ElevenLabs Voice Agents:** Lucy's

I built a CLI that installs the right AI agent skills for your project in one command (npx skillsense)

Hey r/ClaudeAI, I got tired of spending 20-40 minutes manually setting up skills every time I started a new project. Find the right ones, download them, put them in the right folder, check for conflicts... pure friction. So I built skillsense. npx skillsense That's it. It reads your package.json / pyproject.toml / go.mod / Cargo.toml / Gemfile, detects your stack, and installs the correct SKILL.md files into .claude/skills/ (or .opencode/, .github/skills/, .vscode/ depending on your agent). What it does: • Detects 27 stacks: Next.js, React, Vue, Django, FastAPI, Rails, Go, Rust, Prisma, Supabase, Tailwind, Stripe, Docker... • Applies combo rules (e.g. Next.js + Prisma + Supabase installs all three in the right order) • Verifies SHA-256 integrity on every download • Full rollback if anything fails • Works with Claude Code, OpenCode, GitHub Copilot, and VS Code Flags: --dry-run, --yes, --global, --agent It's open source and the catalog is a YAML file in the repo — easy to contribute new skills. GitHub: https://github.com/andresquirogadev/skillsense npm: https://www.npmjs.com/package/skillsense Happy to hear what stacks you'd want added! submitted by /u/AndresQuirogaa [link] [comments]

got sick of telling claude the same stuff every session so i built a thing

right so every time i start a new claude code session its the same conversation. "be concise." "dont use prisma." "conventional commits." "i write go not python." absolute groundhog day. so i built devid - one toml file with your identity in it, distributed to claude code, cursor, claude.ai, wherever. you tell it once and its done. the bit thats actually clever - theres a session-end hook that watches your claude code sessions for corrections and preferences. if you say "dont do it like that" or "i prefer X" it picks it up and queues it. if nothing interesting happened in the session it doesnt even make an api call. no tokens wasted. whole identity fits in about 290 tokens. fragments not sentences. been using it myself for a couple of days now and honestly the difference is night and day. claude just knows how i work from the first message. https://github.com/Naly-programming/devid dead easy to install: curl -fsSL https://raw.githubusercontent.com/Naly-programming/devid/main/install.sh | sh submitted by /u/Lazy-Explanation-467 [link] [comments]

Claude Code was making me re-explain my entire stack every session. Found a fix.

Every time I started a Claude Code session I was doing this ritual: "Ok so this project uses Next.js 14, PostgreSQL with Prisma, we auth with NextAuth, tokens expire after 24 hours, the refresh logic is in /lib/auth/refresh.ts, and by the way we already debugged a race condition in that file two weeks ago where..." You know the feeling. Claude is genuinely brilliant but it wakes up with complete amnesia every single time, and if your project has any real complexity you're spending the first 10-15 minutes just rebuilding context before you can do anything useful. Someone on HN actually measured this. Without memory, a baseline task took 10-11 minutes with Claude spinning up 3+ exploration agents just to orient itself. With memory context injected beforehand, the same task finished in 1-2 minutes with zero exploration agents needed. That gap felt insane to me when I read it, but honestly it matches what I was experiencing. This problem is actually a core foundation of Mem0 and why integrating it with Claude Code has been one of the most interesting things to see come together. It runs as an MCP server alongside Claude, automatically pulls facts out of your conversations, stores them in a vector database, and then injects the relevant ones back into future sessions without you lifting a finger. After a few sessions Claude just starts knowing things: your stack, your preferences, the bugs you've already chased down, how you like your code structured. It genuinely starts to feel personal in a way that's hard to describe until you experience it. Setup took me about 5 minutes: 1. Install the MCP server: pip3 install mem0-mcp-server which mem0-mcp-server # note this path for the next step 2. Grab a free API key at app.mem0.ai. The free tier gives you 10,000 memories and 1,000 retrieval calls per month, which is plenty for individual use. 3. Add this to your .mcp.json in your project root: json { "mcpServers": { "mem0": { "command": "/path/from/which/command", "args": [], "env": { "MEM0_API_KEY": "m0-your-key-here", "MEM0_DEFAULT_USER_ID": "default" } } } } 4. Restart Claude Code and run /mcp and you should see mem0 listed as connected. Here's what actually changes day to day: Without memory, debugging something like an auth flow across multiple sessions is maddening. Session 1 you explain everything and make progress. Session 2 you re-explain everything, Claude suggests checking token expiration (which you already know is 24 hours), and you burn 10 minutes just getting back to where you were. Session 3 the bug resurfaces in a different form and you've forgotten the specific edge case you uncovered in Session 1, so you're starting from scratch again. With Mem0 running, Session 1 plays out the same way but Claude quietly stores things like "auth uses NextAuth with Google and email providers, tokens expire after 24 hours, refresh logic lives in /lib/auth/refresh.ts, discovered race condition where refresh fails when token expires during an active request." Session 2 you say "let's keep working on the auth fix" and Claude immediately asks "is this related to the race condition we found where refresh fails during active requests?" Session 3 it checks that pattern first before going anywhere else. The same thing happens with code style preferences. You tell it once that you prefer arrow functions, explicit TypeScript return types, and 2-space indentation, and it just remembers. You stop having to correct the same defaults over and over. A few practical things I learned: You can also just tell it things directly in natural language mid-conversation, something like "remember that this project uses PostgreSQL with Prisma" and it'll store it. You can query what it knows with "what do you know about our authentication setup?" which is surprisingly useful when you've forgotten what you've already taught it. I've been using this alongside a lean CLAUDE.md for hard structural facts like file layout and build commands, and letting Mem0 handle the dynamic context that evolves as the project grows. They complement each other really well rather than overlapping. For what it's worth, mem0’s (the project has over 52K GitHub stars so it's not some weekend experiment) show 90% reduction in token usage compared to dumping full context every session, 91% faster responses, and +26% accuracy over OpenAI's memory implementation on the LOCOMO benchmark. The free tier is genuinely sufficient for solo dev work, and graph memory, which tracks relationships between entities for more complex reasoning, is the only thing locked behind the paid plan, and I haven't needed it yet. Has anyone else been dealing with this? Curious how others are handling the session amnesia problem because it was genuinely one of my bigger frustrations with the Claude Code workflow and I feel like it doesn't get talked about enough relative to how much time it actually costs. submitted by /u/singh_taranjeet [link] [comments]

I built Claude Code skills that scaffold full-stack projects so I never have to do boilerplate setup again

I’ve been building client projects for years, and the setup phase always slowed me down — same auth setup, same folder structure, same CI config every time. So I built Claude Code skills to handle this interactively: /create-frontend-project — React, Next.js, or React Native /create-node-api — Express or NestJS with DB + auth /create-monorepo — full Turborepo with shared packages /scaffold-app — full folder structure + components + extras It always pulls the latest versions (no outdated pinned deps), and I run nightly smoke tests to catch any upstream issues. Supports 50+ integrations like HeroUI v3, shadcn, Redux, Zustand, Prisma, Drizzle, TanStack, and more. MIT licensed: https://github.com/Global-Software-Consulting/project-scaffolding-skills Would love feedback if you’re using Claude Code 🙌 submitted by /u/BackgroundTimely5490 [link] [comments]

I built an AI bookkeeping app with Claude Code

I’ve been building AICountant with Claude Code and it’s finally at a point where it feels useful enough to share here. It’s an AI bookkeeping app for freelancers, self-employed people, and small businesses. What it does: Upload a receipt photo through the site, or send one through Telegram / Discord Extract vendor, date, total, tax, and line items automatically Convert foreign currency receipts using the historical exchange rate from the receipt date Organize everything into a clean searchable ledger Support English and French Give deduction guidance during review Claude Code helped with most of the actual implementation. I used it across the stack for Next.js App Router, Prisma + PostgreSQL, Vercel Blob storage, UI iteration, and the receipt-processing flow. A good example was the currency conversion feature. I asked for multi-currency support and Claude helped wire the full flow together: schema updates, exchange-rate fetching, caching, error handling, and UI updates. That would have taken me a lot longer solo. A big reason I built it this way was to reduce friction. I didn’t want receipt tracking to be something people only do later from a dashboard, so I wanted chat-based capture to be part of the workflow from the start. It’s free to try in beta right now. Link: https://ai-countant.vercel.app/ Beta code: HUJA-VJG5 Happy to answer questions about the stack, workflow, or what using Claude Code felt like on a real project. submitted by /u/Ok_Lavishness_7408 [link] [comments]

I built 9 free Claude Code skills for medical research — from lit search to manuscript revision

I'm a radiology researcher and I've been using Claude Code daily for about a year now. Over time I built a set of skills that cover most of the research workflow — from searching PubMed to preparing manuscripts for submission. I open-sourced them last week and wanted to share. What's included (9 skills): search-lit — Searches PubMed, Semantic Scholar, and bioRxiv. Every citation is verified against the actual API before being included (no hallucinated references). check-reporting — Audits your manuscript against reporting guidelines (STROBE, STARD, TRIPOD+AI, PRISMA, ARRIVE, and more). Gives you item-by-item PRESENT/PARTIAL/MISSING status. analyze-stats — Generates reproducible Python/R code for diagnostic accuracy, inter-rater agreement, survival analysis, meta-analysis, and demographics tables. make-figures — Publication-ready figures at 300 DPI: ROC curves, forest plots, flow diagrams (PRISMA/CONSORT/STARD), Bland-Altman plots, confusion matrices. design-study — Reviews your study design for data leakage, cohort logic issues, and reporting guideline fit before you start writing. write-paper — Full IMRAD manuscript pipeline (8 phases from outline to submission-ready draft). present-paper — Analyzes a paper, finds supporting references, and drafts speaker scripts for journal clubs or grand rounds. grant-builder — Structures grant proposals with significance, innovation, approach, and milestones. publish-skill — Meta-skill that helps you package your own Claude Code skills for open-source distribution (PII audit, license check). Key design decisions: Anti-hallucination citations — search-lit never generates references from memory. Every DOI/PMID is verified via API. Real checklists bundled — STROBE, STARD, TRIPOD+AI, PRISMA, and ARRIVE checklists are included (open-license ones). For copyrighted guidelines like CONSORT, the skill uses its knowledge but tells you to download the official checklist. Skills call each other — check-reporting can invoke make-figures to generate a missing flow diagram, or analyze-stats to fill in statistical gaps. Install: git clone https://github.com/aperivue/medical-research-skills.git cp -r medical-research-skills/skills/* ~/.claude/skills/ Restart Claude Code and you're good to go. Works with CLI, desktop app, and IDE extensions. GitHub: https://github.com/aperivue/medical-research-skills Happy to answer questions about the implementation or take feature requests. If you work in a different research domain, the same skill architecture could be adapted — publish-skill was built specifically for that. submitted by /u/Independent_Face210 [link] [comments]