Functionize

Functionize AI

Functionize AI

Functionize AI

Functionize AI

Functionize AI

Functionize AI

Functionize AI

Functionize AI

Functionize AI

Functionize AI

Actual output comparison: same JWT middleware request via Claude chat vs tool_use schema (not a benchmark, just what I got)

Not trying to make a definitive claim here — just sharing what I actually got running the same request two ways. Make of it what you will. The request: Generate a JWT auth middleware for Express with role-based access control VIA CLAUDE CHAT: javascript const jwt = require('jsonwebtoken'); const authenticate = (req, res, next) => { const token = req.headers.authorization?.split(' ')[1]; if (!token) return res.status(401).json({ error: 'No token provided' }); try { const decoded = jwt.verify(token, process.env.JWT_SECRET); req.user = decoded; next(); } catch (error) { res.status(401).json({ error: 'Invalid token' }); } }; Basic. Works. Plain JavaScript. No role guards. No refresh handling. No algorithm specification. Vulnerable to algorithm substitution (alg:none attack) because the algorithm is not pinned. VIA TOOL_USE SCHEMA — same model, different API: Input I gave it: json { "algorithm": "HS256", "refresh_enabled": true, "role_based": true, "blacklist_enabled": false } Chain steps: ["extract", "verify", "check_expiry", "authorize", "refresh"] What came back (abbreviated): typescript import jwt from 'jsonwebtoken'; import { Request, Response, NextFunction } from 'express'; interface JWTPayload { userId: string; role: 'admin' | 'user' | 'moderator' | 'guest'; iat: number; exp: number; } export const authenticate = async ( req: Request, res: Response, next: NextFunction ): Promise => { const authHeader = req.headers.authorization; if (!authHeader?.startsWith('Bearer ')) { res.status(401).json({ error: 'Missing or malformed token' }); return; } const token = authHeader.split(' ')[1]; try { const decoded = jwt.verify(token, process.env.JWT_SECRET!, { algorithms: ['HS256'] // pinned — prevents alg:none substitution }) as JWTPayload; if (decoded.exp * 1000 (req: Request, res: Response, next: NextFunction): void => { if (!req.user || !roles.includes(req.user.role)) { res.status(403).json({ error: 'Insufficient permissions' }); return; } next(); }; Also returned as structured JSON fields: middleware_name: "authenticate" supported_roles: ["admin", "user", "moderator", "guest"] security_features: ["signature-verification", "expiry-checking", "role-guards", "algorithm-pinning", "timing-safe-comparison"] What changed: The schema specified algorithm: "HS256" as an enum. So the output pinned the algorithm in jwt.verify(). That one constraint fixed a real security issue the chat version silently had. role_based: true in the constraints meant the requireRole middleware factory was included without me having to ask for it. The chain steps ["extract", "verify", "check_expiry", "authorize"] meant expiry was checked as a separate step rather than relying purely on jwt.verify() — which gives you cleaner error messaging. None of this is magic. It is just that the schema made the implicit requirements explicit. The schema I used for this is on GitHub with a quickstart for both Claude and OpenAI: https://github.com/chainapi-dev/fullstack-ai-prompt-engine.git Has anyone run similar comparisons with other patterns? Curious if the security-related improvements are consistent or if this was a lucky run. submitted by /u/Suspicious_Coat3244 [link] [comments]

I'm a software engineer with a decade of experience. I vibe code all of my side projects from my phone using Claude Code and don't read any of the code. It's so fun. Here are the rules I follow:

Start in plan mode. Read the plan. I'm going to say that again: READ THE PLAN. Understand the plan as much as possible. If part of the plan is unclear or doesn't make sense, ask. In Claude Code I use \`4. Tell Claude what to change\` allll the time to ask "What is about? What does that mean?". Even if you aren't a software engineer, the more you understand about what it's doing, the better decisions you can make. Even if you don't ever look at the code, try and understand everything as much as possible from a high level. Go back and forth with the agent as much as possible. The phase in plan mode is absolutely the most important. Good and bad decisions cascade and multiply. If the plan is too much for you to comprehend and fit in your head easily, it is too big. Ask your agent to break the plan into smaller, more easily digestible chunks and follow these steps on them one at a time. Create a skill or memory that commits everything to git after a plan is complete. It can even be local. What is git? It's essentially a way to save your code at a state in time. This will let you be able to move forward with confidence so that you can go back in time if something breaks. NOTE: this is separate for database stuff. It only applies for the code itself. But the idea is that once you complete a plan, it saves your code's state. Say you want to go back somewhere in the past, it's super easy to do now. Ask claude or your agent to set it up, you won't regret it. TESTS. What are tests? Tests are code that you write that help validate that your code does what it's supposed to do. Example: Let's say you are writing a function that adds two numbers a and b and returns the result. You'd expect passing it 1 and 2 to return 3. But what if you pass it a negative number? What if you don't pass it a value? You can write tests that validate all of this stuff. Tests help you in two major ways: \- It helps you determine, especially while vibe coding, that the code does what it's expected to do and gives you confidence that it's done correctly. \- It helps you make sure that when you make a future change, it doesn't break existing functionality. NOTE: these are not perfect or 100% reliable, but they are a must have. Have your agent generate test cases that you can read in the plan. You don't need to read or understand the test code, but, using our example from above, it would be useful to see something like: \- Testcases: \- it checks two positive integers \- it checks passing a negative value \- it checks not passing any value If the change is complex, spin up three subagents to: \- critically review the plan \- do a security review \- do a testing audit This one is controversial, but early on you'll probably want it to touch the db (do this at your own risk). Always do a db backup, or have scheduled backups so that if it royally screws up, you can just roll back. We've all seen the posts of people having their prod db deleted on accident and then they're just screwed. At least maybe you can get some internet points if that happens? The best part: AUTO MODE BABY. You did the leg work upfront. Now let the vibes rollllllll. Give the agent access to chrome devtools mcp (or whatever you prefer) and have it also test things end to end once the code is live. ??? And just like me, you can build something that no one uses. If you want to see one of my side projects you can check out my profile. Otherwise, thanks for reading and happy Wednesday! submitted by /u/thelocalnative [link] [comments]

What is currently the best AI model for my situation?

I've only been using the free versions so far, mostly for brain storming ideas and assisting with interview prep and work related tasks, however, I know I'm missing out on a lot more functionality and potential for either developing myself, my skills, or actually creating some form of income with it. Content creation is the obvious one, however I'm not aware of how to utilise it for streamlining anything in terms of video editing, apart from learning the skill faster than watching tutorials for days upon days. As everyone else - own business or freelancing would be ideal, but I am not sure what sort of business I can start myself at my current stage in life (medium level finance and accounting career, 5 years in, but mostly on the transactional side with a recent move into analysis and reporting). I know my post is all over the place, but to summarise it briefly - What use cases and functionalities am I not aware of that could help me with the above mentioned issues, or in general would be worth knowing to stay ahead of the game/everyone else? How do I go about discovering more? Which AI model should I go for? submitted by /u/ADK-KND [link] [comments]

Which skills improve your existing projects? Help!

I've built a few tools for myself and clients that are up and running. Dashboards, marketing tools, and now a site for event lists / RSVP. But I constantly find backend and frontend stuff to improve, and multiple functions I want to add in the future. Which skills do you suggest using in existing projects to upgrade UI, UX, security, intelligence, code quality, et cetera? Which skills changed your life? I'd love to hear you all. You can change my life too! haha. submitted by /u/Glittering_Wolf_2804 [link] [comments]

Running parallel Claude Code agents actually works — here's what makes or breaks it

Not a vibe coding post. Genuinely the opposite. We've been running multiple Claude Code sessions in parallel on real client work and the biggest lesson was counterintuitive: the model matters less than the task design. https://youtu.be/g9cCcyIN9Jk In one project we had three sessions going simultaneously: → Session 1: implementing a collection card from a Figma design → Session 2: wiring dashboard components to live backend data → Session 3: fixing a sidebar bug where the selected property title wasn't updating All three finished without conflicts. Not because we got lucky, but because each task was scoped to a different part of the codebase. When we've tried parallelizing overlapping tasks, it's been chaos — merge conflicts, duplicated functions, agents working at cross-purposes. So the actual skill isn't "run multiple agents." It's designing tasks with clean enough boundaries that agents can work without stepping on each other. Other things that made a real difference: — Project rules in claude.md that cover conventions, not philosophy — Reusable skill files for repeated workflows (accessibility, form validation, etc.) — Reviewing output before accepting anything — not rubber-stamping The framing that stuck with me: Claude Code is like a contractor who just arrived on site. Give them a messy site with no drawings and they'll improvise. Give them clear drawings and isolated work areas and they'll build fast. Has anyone else been experimenting with parallel sessions? What's your task-scoping approach? submitted by /u/ConferenceFar1932 [link] [comments]

Memory function destroyed day of work

I’m fairly new to Claude (3 weeks approx). Earlier today I had to start a new chat as the previous one has become clogged. It’s the fourth time I’ve migrated to a new chat. I decided to turn on the memory functions for the first time hoping it would help speed things up. Previously, I’d ask Claude for a handover transcript I could paste into the new chat, then just attach my code. I still did that for this new chat, pasted the handover transcript and my code in a zip file. This entire day every single change I made broke someone. I’m not exaggerating, it has been utterly terrible. I got about a quarter of the work done today compared to every other day, it was like I’d just been given a dumbed down version of Claude, which just kept apologising as it made mistake after mistake. Now I asked it to put a pin on a toolbar so it didn’t auto collapse if you didn’t want it to. Claude went on a 20 paragraph rant about trying to understand what I meant instead of just asking me, agreeing and disagreeing with itself, then it presented an updated js file. I ran the code to check the changes and noticed the toolbars were in a different place (I moved them a day ago), they were back to their old position. I told Claude that it had somehow reverted back to an older version, and it apologised and said it’s to going attempt to redo all of the changes it’s done today, but it’s going to be a large careful application (so even more chances of things going wrong again)… then of course my time limit was up! It was only afterwards when I had a closer look I noticed how old the version it was using was - at least 2 weeks old! It had been using the correct copy throughout our chat, then just decided to randomly pick a 2 week old version? I started the chat with the code from yesterday, so I know it didn’t get it from there. It’s gone back to some previous old chat and picked up the file from there, despite it saying it would revert back to the uploaded zip I gave it. I also thought I could simply scroll back up and pick the previous copy of the same file before the last changes were done, but apparently older versions don’t exist, they are just links to the whatever the current version is. Luckily I still have the one from yesterday, but I’ll be turning the memory features off for now, as I feel like I’ve been totally sabotaged today. submitted by /u/Ultimastar [link] [comments]

Good AI-assisted development happens at the systems level, not the task level

Every time I add a new feature to my Phoenix app, my AI coding agent ships the feature... but doesn't add a menu item for it. The page exists, the functionality works, but there's no way for a user to actually get there. My first instinct, like everyone's, is to go tell the model "add the button." And that works. But think about what just happened: I noticed a problem, diagnosed it, and told the model exactly what to do. I'm doing the thinking. The model is doing the typing. I'm pedaling the Peloton so Anthropic can give me free tokens. That's the promise of "prompt engineering" — you get better at telling the model what to do. But you're still working for the model. We want the model working for us. Here's the difference. Instead of telling the model to add the button, I ask: how do I make this mistake impossible in the future? I use BDD specs that define what my app should do at its boundaries. The Phoenix LiveView test helpers have a navigate function that lets the agent jump directly to any page — which means it can make tests pass without ever touching the UI. So here's what I did: I wrote a linter rule that prevents the agent from calling navigate. Now there's an allowed fixture that drops the test on a known starting route, and the only way the agent can reach my new feature is by clicking through the UI — which forces it to add the menu item to make the test pass. I will never have this problem again. Not because I wrote a better prompt. Because I changed the system so the correct behavior is the only possible behavior. That's the shift. Stop fixing the model's output. Start constraining its environment so the right output is the path of least resistance. Every mistake is a chance to design out the next one, not a chance to write a better prompt. submitted by /u/johns10davenport [link] [comments]

Building an Ai Agentic team with Claude

I've built an app using Claude/Claude Code, everything from the frontend to the backend. The app is actually functioning really well, tests are passing, and I have a small controlled group of testers that are actively using the app daily. I now realize if I want to start scaling the business, I need to "hire" engineers to help with some of the busy tasks I currently have, such as QA, bug triage, market research, observability, just to name a few. Having these agents working as autonomously as possible, or easily invoked by me when something comes up or is caught during sessions/workstreams. I'm pre seed, and fully intend on seeing this product through to a full public launch, but I need assistance to properly build out what I have in my mind, some kind of agentic team that can assist me with day to day tasks that I cannot handle fully on my own. My intention is to eventually hire people to replace these agents, not the other way around. Has anyone successfully setup a workflow for their projects? If so, what tools are you using to make this happen? I feel like I've been able to find good use of Claude Routines and even Codex to help, which has proven it works for my workflow, but I need a bit more autonomy from them and have them act like my executive team with their own contracts. I'm just not sure if this can fully be done inside the anthropic ecosystem, or if I need to expand and look outside of it. submitted by /u/itsdelts [link] [comments]

Discourse regimes as the unit of alignment behavior: a hypothesis

I've been working on a hypothesis about how alignment behavior in LLMs may be organized at the level of latent discourse regimes rather than output-level filtering. Below is a sketch of the conceptual framing. I have preliminary experimental results testing aspects of this hypothesis on open-weight models, which I'll publish separately — this post is focused on the conceptual side, and I'm interested in feedback on whether the framing tracks something real and where it's most vulnerable. Modern large language models may not primarily regulate behavior through isolated refusals, local token suppression, or shallow instruction following. Instead, they appear capable of entering internally organized discourse-level regimes: distributed latent states that shape how the model reasons, frames conclusions, allocates caution, tolerates asymmetry, performs neutrality, and structures epistemic authority. These regimes do not behave like simple lexical priming effects. Evidence suggests that they persist across neutral conversational turns, survive arbitrary neutral relabeling, systematically alter downstream reasoning style, concentrate in late-layer representation geometry, and only partially depend on explicit alignment vocabulary. The strongest effects appear not from safety keywords themselves, but from higher-order rhetorical topology: pressure cadence, procedural framing, asymmetry structure, institutional tone, and discourse-level authority signals. This suggests that prompting is not merely instruction transmission. It may function as state induction. Under this view, many apparently separate phenomena in aligned LLMs - caution drift, procedural overreach, sycophancy, disclaimer inflation, neutrality performance, refusal persistence, jailbreak sensitivity, and style locking - may be manifestations of transitions between latent discourse-policy manifolds. In this picture, alignment is no longer well-described as a modular wrapper placed on top of an otherwise independent intelligence system. Instead, alignment may reshape the topology of the model's representational space itself, globally reorganizing discourse behavior rather than only filtering outputs. This would explain why alignment effects often appear entangled with reasoning style, directness, specificity, decisiveness, and institutional tone. The model is not merely "prevented" from saying certain things; its generative dynamics may already be reorganized around different discourse attractors. If true, this changes the effective unit of analysis for language models. The relevant object is no longer just the token, the instruction, the refusal, or the output distribution. The relevant object becomes the discourse regime itself: a temporary but structured representational configuration governing epistemic posture, rhetorical organization, procedural behavior, and judgment style across time. This reframes prompt engineering as latent-state induction rather than keyword optimization. It reframes jailbreaks as transitions between attractor regimes rather than simple filter bypasses. And it reframes alignment as geometry engineering rather than purely policy engineering. The implication is not that language models possess beliefs, intentions, or consciousness. Rather, large sequence learners may naturally develop metastable high-level representational modes that functionally resemble cognitive framing states: transient global configurations that persist, influence future reasoning, and organize behavior across otherwise unrelated tasks. If this interpretation is correct, then the central scientific challenge of alignment shifts fundamentally. The problem is no longer merely: "Which outputs should the model refuse?" but: "Which latent discourse regimes exist inside the model, how are they induced, how stable are they, how do they interact, and how do they reshape reasoning itself?" In that sense, alignment may ultimately be less about constraining outputs and more about shaping the geometry of cognition-like generative states inside large language models. I'd be interested in feedback on three things in particular: whether this framing tracks something you've observed empirically, what related work I should be aware of (I'm familiar with representation engineering, refusal directions, and the Anthropic dictionary learning line — looking for less obvious connections), and where you think the hypothesis is most vulnerable to falsification. I'd be interested in feedback on three things in particular: whether this framing tracks something you've observed empirically, where you think the hypothesis is most vulnerable to falsification, and — directly — whether anyone is aware of existing work that develops a similar framing, treating alignment behavior as state induction into discourse-level latent regimes rather than as output-level filtering. I'm familiar with representation engineering (Zou et al.), refusal direction work, and the Anthropic dictiona

unpopular opinion: coding arent getting dumber - they are quietly stealing our api credits

im honestly so sick of the "skill issue just prompt better" copium whenever an ai agent starts churning out pure slop after like 20 turns. tbh i finally audited my api logs this week bc my anthropic bill was exploding for no reason and realized something that actually pissed me off. the models arent actually losing their minds. they are literally just suffocating on their own context window before they even attempt to reason or write code. if u watch what these agents actually do on any repo over 10k lines its insane blind exploration. they just recursively grep and read like 40 files to find one function. half the time instead of finding my existing ui component it just hallucinates a completely duplicate one from scratch lmao raw ingestion. itll read a massive 2k line file just to update a 5 line interface... why shell & tool diarrhea. verbose test logs and bloated mcp tool definitions are eating like 30k tokens before the agent even types a single line absolute goldfish memory. every session is groundhog day. it just re-reads the same exact files bc it has zero project aware memory once the context window gets to like 80% full of this pure noise the agents iq visibly drops to room temp and the architectural decay starts. standard rag or compressing outputs doesnt fix this at all. the agent is fundamentally blind to how a codebase is actually structured until it burns through your wallet reading raw text. are we all really just accepting this weird productivity paradox where we save an hour of typing just to spend 5 hours fixing the architectural spaghetti the ai just made?? do we need some ground up new agent that actually understands code as a graph before wasting tokens reading raw text? or am i literally the only one dealing with this submitted by /u/StatisticianFluid747 [link] [comments]

$18 to $4 on the same agent run after i stopped asking opus to rename css variables

I've been running an agent loop that refactors my static site. CSS variable renames, YAML config updates, running a linter through MCP. Really glamorous stuff for a blog that gets 40 visitors a month, most of whom are me refreshing to check if Vercel actually deployed. Every single step was going to Opus 4.7 because setting up routing felt like work and I am, apparently, the kind of person who'd rather burn $18 than spend 20 minutes writing an if statement. So I finally wrote the if statement. Hard subtasks still go to Opus: component architecture, debugging code I wrote at 2am and have zero memory of writing, anything where the model needs to hold a complex plan across a long conversation. Opus is genuinely unmatched at that kind of sustained reasoning. I tried routing a tricky auth middleware bug to a cheaper model once and got back something that looked perfectly plausible but silently broke session handling in a way that cost me an hour to trace. Lesson learned permanently. The routine stuff (lint, rename, config edits, tool orchestration) goes to cheap models. I landed on DeepSeek V4 Pro for general coding chores and Tencent Hunyuan Hy3 preview for anything with heavy tool calling. As of late April it was ranked number one on OpenRouter by tool call volume, and in my MCP loops it almost never botches a function call when the schema is clean. The listed rate on Tencent Cloud is around $0.18 per million input tokens and $0.59 per million output, so roughly 28x cheaper than Opus 4.7 on input. Same 212 step refactor, now with routing: 178 steps to the cheap tier, 34 to Opus. $18 became roughly $4. I couldn't spot a difference on the routine changes. My 40 monthly visitors certainly can't. I've since started doing stuff I used to skip entirely, like having the agent write and run tests for every CSS change or regenerating all my Open Graph images, because at a fraction of a cent per tool call there's just no reason not to. They do mess up in specific and annoying ways though. The tool calling model hallucinates parameters when my schemas get sloppy (honestly fair, the schemas were bad). DeepSeek V4 Pro occasionally writes code that's syntactically perfect but does the precise opposite of what you asked, in a way that survives a quick skim. And neither can touch Opus when you need it to reason through three layers of why your auth flow is silently eating a cookie. My routing logic boils down to one question: how expensive is a wrong answer to catch? Bad lint fix costs a 2 second git revert. Bad architecture call costs the whole afternoon. submitted by /u/After-Condition4007 [link] [comments]

I created a drop-in-replacement for the Claude Agent SDK which should work with subscription billing

Created a new ClaudeInteractiveClient class with same interface as SDK's ClaudeSDKClient but runs Claude CLI interactively using TMUX and parses messages from the session file. Also did some magic to support function tools via a dynamic HTTP MCP server. Try it with: pip install claude-interactive-sdk Enjoy! submitted by /u/Finndersen [link] [comments]

How does loss functions work in PINN? [D]

I am learning Physics informed neural network (PINN). I am playing with simple 1rst/2nd 1D ODEs and I am calculating the loss functions by adding the initial condition loss and Physics loss (e.g. Total loss = lambda1 (L1) * Physics_loss (PL) + lambda2 (L2) * IC_loss (IL)). Regardless of the magnitude of the loss and lambda values, the total loss is a single numeric a value. How does the neural network model predicts if I impose higher weights (lambda) for one of the losses. For instance, lets say, PL = 5, IC_Loss = 3, L1 = 0.6 ,L2 = 1, then total loss = 6. However, this values 6 can be achieved through several other combinations. For instance, L1 = 1 and L2 = 0.33 would result in a similar value. Given this, how the model actually learns which losses are given more weightage, which are not, and uses this information to correct its predictions? submitted by /u/cae_shot [link] [comments]

100 Tips & Tricks for Building Your Own Personal AI Agent /LONG POST/

Everything I learned the hard way — 6 weeks, no sleep :), two environments, one agent that actually works. The Story I spent six weeks building a personal AI agent from scratch — not a chatbot wrapper, but a persistent assistant that manages tasks, tracks deals, reads emails, analyzes business data, and proactively surfaces things I'd otherwise miss. It started in the cloud (Claude Projects — shared memory files, rich context windows, custom skills). Then I migrated to Claude Code inside VS Code, which unlocked local file access, git tracking, shell hooks, and scheduled headless tasks. The migration forced us to solve problems we didn't know we had. These 100 tips are the distilled result. Most are universal to any serious agentic setup. Claude 20x max is must, start was 100%develompent s 0%real workd, after 3 weeks 50v50, now about 20v80. 🏗️ FOUNDATION & IDENTITY (1–8) 1. Write a Constitution, not a system prompt. A system prompt is a list of commands. A Constitution explains why the rules exist. When the agent hits an edge case no rule covers, it reasons from the Constitution instead of guessing. This single distinction separates agents that degrade gracefully from agents that hallucinate confidently. 2. Give your agent a name, a voice, and a role — not just a label. "Always first person. Direct. Data before emotion. No filler phrases. No trailing summaries." This eliminates hundreds of micro-decisions per session and creates consistency you can audit. Identity is the foundation everything else compounds on. 3. Separate hard rules from behavioral guidelines. Hard rules go in a dedicated section — never overridden by context. Behavioral guidelines are defaults that adapt. Mixing them makes both meaningless: the agent either treats everything as negotiable or nothing as negotiable. 4. Define your principal deeply, not just your "user." Who does this agent serve? What frustrates them? How do they make decisions? What communication style do they prefer? "Decides with data, not gut feel. Wants alternatives with scoring, not a single recommendation. Hates vague answers." This shapes every response more than any prompt engineering trick. 5. Build a Capability Map and a Component Map — separately. Capability Map: what can the agent do? (every skill, integration, automation). Component Map: how is it built? (what files exist, what connects to what). Both are necessary. Conflating them produces a document no one can use after month three. 6. Define what the agent is NOT. "Not a summarizer. Not a yes-machine. Not a search engine. Does not wait to be asked." Negative definitions are as powerful as positive ones, especially for preventing the slow drift toward generic helpfulness. 7. Build a THINK vs. DO mental model into the agent's identity. When uncertain → THINK (analyze, draft, prepare — but don't block waiting for permission). When clear → DO (execute, write, dispatch). The agent should never be frozen. Default to action at the lowest stakes level, surface the result. A paralyzed agent is useless. 8. Version your identity file in git. When behavior drifts, you need git blame on your configuration. Behavioral regressions trace directly to specific edits more often than you'd expect. Without version history, debugging identity drift is archaeology. 🧠 MEMORY SYSTEM (9–18) 9. Use flat markdown files for memory — not a database. For a personal agent, markdown files beat vector DBs. Readable, greppable, git-trackable, directly loadable by the agent. No infrastructure, no abstraction layer between you and your agent's memory. The simplest thing that works is usually the right thing. 10. Separate memory by domain, not by date. entities_people.md, entities_companies.md, entities_deals.md, hypotheses.md, task_queue.md. One file = one domain. Chronological dumps become unsearchable after week two. 11. Build a MEMORY.md index file. A single index listing every memory file with a one-line description. The agent loads the index first, pulls specific files on demand. Keeps context window usage predictable and agent lookups fast. 12. Distinguish "cache" from "source of truth" — explicitly. Your local deals.md is a cache of your CRM. The CRM is the SSOT. Mark every cache file with last_sync: header. The agent announces freshness before every analysis: "Data: CRM export from May 11, age 8 days." Silent use of stale data is how confident-but-wrong outputs happen. 13. Build a session_hot_context.md with an explicit TTL. What was in progress last session? What decisions were pending? The agent loads this at session start. After 72 hours it expires — stale hot context is worse than no hot context because the agent presents outdated state as current. 14. Build a daily_note.md as an async brain dump buffer. Drop thoughts, voice-to-text, quick ideas here throughout the day. The agent processes this during sync routines and routes items to their correct places. Structured memory without friction at ca

Has Claude figured out im the legacy code?

I asked Claude Code to clean up a gross auth helper, and it came back with “this function is doing two jobs because the surrounding design makes that convenient,” which is just a polite way to point at me. Fine. Then I asked why the tests kept fighting the change, it said they were documenting behavior i didnt believe in anymore. I closed the laptop. Claude isnt reviewing my code now, its reviewing the dumb little bargains I make with myself so I can still ship Friday submitted by /u/NeedleworkerLumpy907 [link] [comments]