Pieces

Pieces AI

Pieces AI

Pieces AI

Pieces AI

Pieces AI

Pieces AI

Pieces AI

Pieces AI

Pieces AI

Pieces AI

Is AI making us dumber?

Does anybody else feel like AI is making information access so trivial that it is in turn making us dumber? Like we don't need to go through the pain and effort of learning & remembering things as much anymore since we can just ask ChatGPT or Claude to explain it to us whenever we need it? I imagine this problem is going to cause a lot of downstream effects where a piece of background information you might've needed to know but didn't will cause you a lot of pain and suffering yet you won't even know the reason why. For example, say Claude Code writes your ORM code to display all posts and their comments. Works perfectly in dev with 10 posts. In production with 10,000 posts, it's making 10,001 database queries per page load and your database melts. Without understanding how ORM lazy loading works, you'd never spot it from reading the code, because the code looks completely innocent. This is the exact thing I worry about as people adopt AI tools more and more, and some even depend on them entirely. Anybody else have this feeling like we're just getting dumber? submitted by /u/Necessary-Course9154 [link] [comments]

My Claude Code setup: auto-commits, session summaries, deletion guards, and a 200-line CLAUDE.md that doesn't turn into a novel

Been using Claude Code heavily for a native iOS project for the past few weeks. After losing context across sessions more times than I want to admit, I finally sat down and built a proper workflow around it, or I think I did, and open for any suggestions from this community how else this can be done more better. I think most of the advice out there is either too basic or way too enterprise or high level. The main problem was that every new session started cold. Claude Code would re-read files it already understood, ask questions I already answered last session, and occasionally redo work. The context window is finite and long sessions degrade. So I have a system where Claude Code writes a session summary to a docs/sessions/ folder before ending, and reads the most recent one at the start of every new session. It picks up exactly where it left off. Sounds obvious in hindsight but the difference is amazing. The other thing that was killing my flow was the constant permission prompts. Every curl, every cat, every echo, every file write. I was sitting there hitting Y every ten seconds like a human approval bot. So I set up settings.json with broad allow rules for Bash, Read, and Write so it stops asking for the routine stuff. But here's the key part, I added specific deny rules for the actually dangerous commands like rm -rf, git reset --hard, and find -delete. Then I wrote a guard.sh script as a PreToolUse hook that intercepts every bash command and hard blocks anything destructive with exit code 2. Not a warning, an actual block. So now 95% of the session runs uninterrupted and the only time it stops to ask me is when it genuinely should. Sessions went from constant babysitting to kicking off a task and checking back when it's done. The other thing that kept biting me was CLAUDE.md growing into a monster. Every session adds context, decisions, architectural notes, and after a couple weeks you've got a 500 line file that's eating your context window just by existing, and actually larger claude.md files means your sessions reach context limits faster. So I added a rule: CLAUDE.md stays under 200 lines. Anything older or non-critical gets moved to a history.md with a date tag. CLAUDE.md keeps a one-line cross reference so nothing is actually lost. Claude Code maintains this itself, I don't touch it. Auto git commits after features was the last piece. Conventional commit prefixes (feat, fix, style, refactor) so the git log actually tells a story. It pushes after milestones. I also added instructions that it has to git commit working code before any destructive operation so there's always a rollback point. The whole setup is three files. settings.json with permissions, allow/deny rules and hooks. A guard.sh script for the deletion blocker. And the CLAUDE.md additions for session management and workflow rules. Sharing those files here below. Took me a few sessions to get right but now I basically almost never lose context between sessions,No more babysitting permission prompts :) , and I haven't had a scare with accidental deletions since, coz claude knows not to do it :) Hope this helps you all, all the files are there in gist github: https://gist.github.com/ravisirsi/0dfaddeced317597b86755caf0120837 submitted by /u/Sweet-Helicopter2769 [link] [comments]

Claude Code helped me bring my dead passion project back to life

**TL;DR: Claude Code took a half-finished HeroMachine conversion and helped me complete it over a long weekend. I'm the creator of HeroMachine, a free Flash-based character creator that's been around since 1998. Over 25 years I and a handful of other artists hand-drew nearly 10,000 items (heads, bodies, weapons, capes, the works) so people could assemble their own superhero illustrations. It found a real audience in tabletop gamers, writers, teachers, kids who just wanted to see their character come to life, and middle-aged dudes like me who once dreamed of a career in comics. At its peak HeroMachine 3 had tens of thousands of active users. Then Flash died in 2020, and HeroMachine died with it. I tried to rebuild. I really did. I hired a developer, spent thousands of dollars, and got back an unfinished product. I tried redoing it myself, but the sheer scope was paralyzing and I just didn't have the energy any more after working my day job every day. HeroMachine 3 has thousands of hand-drawn items across 30+ equipment slots, each with three-channel coloring, transforms, layering, masking, and more. Rebuilding all of that from scratch while also converting every item from Flash's internal format to SVG? I burned out. Real life got in the way. After a while it just felt like I'd failed, and I stopped trying. Fast forward to earlier this year. In my day job as a web developer, I started using Claude Code to automate tedious migration work like taking old WordPress sites and converting their content into our modern custom-built blocks. The kind of work where you know exactly what needs to happen, it's just painfully repetitive. One Friday night I had the thought: "If it can convert old WordPress content, maybe it can help convert those old HeroMachine items, too." Five days later I had a working app. I want to be real about what that means, because I have the same genuine concerns about AI I know a lot of you do. What AI did NOT do: Draw a single item. Every piece of art is still hand-drawn by me and a small group of human artists over the past 25 years. Every creative decision, from what to draw, how to draw it, and what looks right, is still mine. Design the application. HeroMachine's logic — the architecture, feature set, how items and colors and transforms work together — was designed and written by me in ActionScript over 10+ years. Claude Code helped me translate that existing design into a modern stack, but every decision about what the app should do came from me. What AI did do: Help me translate my existing ActionScript code into modern JavaScript and Svelte. I'd point it at the decompiled ActionScript code, explain how something worked, and it would produced the refactored result. Automate the conversion of thousands of Flash-format items into clean SVGs. Help me debug when I got stuck and build new features quickly when I had ideas. Eliminate the parts that were actually stopping me: the tedium, the unfamiliar syntax, the sheer volume of conversion work that made the whole project feel impossible. I got more done in five days than in the previous five years. Not because the AI is smarter than me, but because it removed the wall between "I know exactly what this should be" and "I can actually ship it." I'll be honest, I find AI companies' business practices troubling. I have real concerns about what AI will do to my own industry and my actual job, not to mention the huge data center being built less than an hour from where I live that could have a massive impact on our environment. I hate that it's positioned to take over the fun, creative parts of work while leaving us with the grunt work. Am I sharpening the axe that will ultimately be used on people like me? Maybe. I've sat with that, and I don't have a clean answer. What I can tell you is that I sunk 25 years into HeroMachine and it was dead. Now it lives again, and I have a hard time convincing myself that's an altogether bad thing. HeroMachine 3 "Phoenix Edition" (it rose from the ashes!) is free and live now if you want to check it out. I'm happy to answer questions about the process, the tech, or the ethics of it. I don't think this is a simple story, but at least it's an honest one. submitted by /u/AFDStudios [link] [comments]

People are losing their minds - has anyone else had their post mistaken for AI?

Has anyone else had this problem? I recently had a post banned from a sub Reddit that I poured my heart and soul into. Something that took me about half an hour to properly write and edit to ensure the spelling was correct etc. It was a genuine piece designed to help the people from that subreddit. Just for the mods to take it down because it was mistakenly identified as AI content. I've messaged them directly but I still am in complete shock by it - Vast Minute submitted by /u/Vast_Minute7288 [link] [comments]

What multi-operator Claude Code looks like once you build the plumbing

Five pieces. Hub in the middle. Four ways to talk to it: a one-line MCP client, a CLI, headless workers in Docker, and a small desktop supervisor. What you get: multiple people attached to the same Claude Code session, watching it think sessions that can route subtasks to each other across repos headless Claude in containers that spawn more containers (agents calling agents) watch and intervene from a browser tab on your phone Hub is on Docker Hub if you want to self-host, or use the hosted one. Repos and walkthrough: https://github.com/clawborrator submitted by /u/fixitchris [link] [comments]

I cancelled my AI notetaker subscription and built my own tool using Claude Code. It works well (and it's free)

It does what Fathom, Otter, and Fireflies charge $15–$30/seat/month for. I shipped a fully working AI meeting note-taker last weekend. I use this exact setup to Records calls then transcribes and Summarizes key points, it then pulls action items and then creates shareable notes all whilst running inside my Claude workflow. . The whole setup takes one weekend to build. --- Here’s how it works:(you can copy this exactly) Step 1 → Fork the repo, drop into Cursor Step 2 → Set env vars: transcription key, database URI, admin creds, session secret Step 3 → Record or upload your meeting Step 4 → The audio gets transcribed Step 5 → Claude turns the transcript into structured notes, decisions, follow-ups, and action items Step 6 → Click “Share link” → send anywhere Total build time: ~1 weekend. Cost: $0/month. --- Why the 5-piece stack is the unlock? Most "build your own SaaS" attempts fall flat because they bolt features together without designing the user flow first. This stack works because the data path was decided before any UI got rendered. Every SaaS feature you pay for has a primitive underneath. Loom = browser recorder + S3 + share links. Otter = Whisper API + database + UI. Calendly = a calendar API + booking page. The features stopped being moats the moment Cursor + Claude could write the glue in an afternoon. You're not paying for technology anymore you're paying for distribution and brand. That's why this build pattern works. The assembly is now free. --- Why Claude? Because meeting notes are not just summaries. They need context. Claude can take a raw transcript and turn it into: * decisions * objections * follow-ups * action items * CRM-ready notes * client context * internal operating memory That is where the value is. --- https://github.com/albertshiney/utter_public submitted by /u/Tabani897_YT [link] [comments]

ChatGPT only lets you delete chats one at a time!! So I built a bulk delete dashboard!!

About a year ago I tried to clean up my ChatGPT chat list. I had something like 800 conversations, two years deep, mostly auto-titled "Untitled chat" garbage that I couldn't tell apart without opening. I sat down to delete the dead ones. Click chat. Click three-dot menu. Click Delete. Confirm. Click the next chat. Same thing. Repeat. After an hour I had deleted maybe 40 chats. Forty!! Out of 800!! That's the rate of clearing a 2-year history in something like three full workdays of just sitting there clicking confirm. I looked for a native bulk option. There isn't one inside ChatGPT itself. The closest is "Delete all chats" in Settings > Data Controls, which is the nuclear all-or-nothing button. There's no "delete the oldest 300" or "archive everything from before March". That's the entire native API. This seemed insane to me given how trivial "Select All plus Delete" is in literally every other product I've used since 2008! So I built the missing piece. What I built It's a Manage Chats modal inside a Chrome extension I ship called ChatGPT Toolbox (also runs on Edge, Brave, Opera, Arc). The modal lists every conversation in your account with checkboxes. Tick what you want gone, click Delete or Archive, and it runs through them in batches of 10 with a progress bar. ChatGPT Toolbox Manage Chats Feature A few details that came out of dogfooding it: Color-coded age badges on every chat. Green for the last week, blue for the last month, amber for the last 6 months, red for older than 6 months. The first thing I realized was that picking what to delete was the hard part, not the deletion itself, and age was the strongest signal for "I will never look at this again". Active vs Archived tabs. Archive ended up getting more use than Delete in my own usage, because I was rarely 100% sure I wouldn't want a chat back. So I made archive a first-class action, not a second-tier option. Live progress bar ("Deleting 23/50") on bulk operations. I tried it without and kept refreshing the page mid-operation thinking it was stuck. Adding the indicator stopped that completely. Search by title to filter the list before you start ticking. Surprisingly useful even on the auto-generated nonsense titles because there's usually some keyword in there. Bulk export to text, markdown, JSON, or PDF. Less critical for cleanup itself, but a few testers asked for it so they could save a chat outside ChatGPT before deleting it. I went from 800 chats to about 60 in 5 minutes using it. Most of those 5 minutes was deciding what to keep, not the deleting itself. How does the workflow look? Open the modal. List loads sorted by recency. Search to narrow it down if you want. Tick checkboxes. Hit Delete or Archive. Confirm. Progress bar runs through them. Done! If you've cleaned up a big ChatGPT history (with or without my tool, or with some clever workflow I haven't seen), would genuinely love to compare approaches in the comments. submitted by /u/Ok_Negotiation_2587 [link] [comments]

Honestly Claude has been kind of insane for creative work.

I’ve been making cinematic edits/promos for a project I’m building and I’m still pretty new to editing, so usually I know the vibe I want but can’t fully piece everything together yet. I started using Claude almost like a creative director and it genuinely helped me shape the scripting, pacing, voice style, visual direction, and even helped me find good references/sites for clips and inspiration. I still edited everything myself obviously, but it made the whole creative process feel way less overwhelming. Feels less like “AI made this” and more like having a second brain to bounce ideas off of lol. If anyone’s interested I could drop the flow/process I used. submitted by /u/uzenaki [link] [comments]

The Borrowed Hour: A two-tier LLM adventure engine

Tl;dr: Created an LLM text adventure engine called The Borrowed Hour inside a Claude Artifact. It uses a two-tier model handoff (Sonnet for openings, Haiku for gameplay) and a forced state machine to keep the AI from losing the plot. It features a unique post-game "Author’s Table" where you can debrief with the AI. P.S. The Claude Artifact preview environment handles API calls differently than the published environment. Prompt caching was removed because it broke the published Artifact. The game View on GitHub (MIT licensed) (Repo made with Claude Code) Play a demo (Claude Artifact) This is another LLM text adventure. I know these have existed for years, but the key difference is that it's architecture is de novo (i.e. built without prior knowledge because I never intended to build this and therefore skipped the part where I looked at the SotA/prior art). How it started It started simple: I just wanted to play a quick game, so I asked Haiku to play GM for a text adventure, but with more freedom than just typing "open door" or "inspect gazebo" (iykyk). Haiku instead built an entire UI inside the chat and things escalated from there. I used Claude's chat interface instead of Claude code like a caveman banging rocks together. I'd feed it ideas, but Claude was the architect and would push back. The starting prompt was just "Create a text-based adventure that allows for more freedom than just 2-word answers." Then I just kept playing and returning information on what I wasn't satisfied with. The narration was too long, the model kept losing the plot. I added ideas for 3 out of 4 pre-built narratives (a subtle time loop, climbing a cyberpunk syndicate ladder, a vision of the future that needs to be prevented, and one that Claude designed freely) and I ensured that the story actually ends once objectives are met instead of just wandering off into aimless chatting. The final artifact that was built is The Borrowed Hour. You'll recognize the typical Claude design language pretty easily. Game mechanics Before getting into the design/architecture, it helps to know how the game works. There are no dice rolls / stats / perception checks. Success relies on your ability to draft a narrative that fits the lore. If you play it smart, you are effectively the co-GM. You can type anything you want from single words to elaborate plans and lies. If your invention sounds plausible, the GM usually rolls with it. In one run, I needed to get an NPC into a restricted temple. I invented a fake piece of temple doctrine about sanctuary. Because it fits the world's internal logic, Haiku just accepted it and made it canon. In order to help keep track there's a ledger that updates each turn to show what your character knows: inventory, NPCs, clues, and a rolling summary. Designing the architecture This was challenging, but it's the fun part for me. The model is forced through a structured tool call on every turn. This was the key to making the game stable, but as the P.S. explains, getting this to work reliably in the published environment required abandoning another key feature (prompt caching). Sonnet writes the opening scene because that first page sets the tone and voice for the rest. Then Haiku takes over for all the continuation turns. This keeps the cost down drastically without ruining the style, because Haiku can imitate Sonnet's established prose. I initially used a binary good/bad ending system, but it forced complex emotional stuff into the wrong buckets. Now there are five ending states: good, bittersweet, pyrrhic, ambiguous, and bad. Helping a dying woman find peace in the Dream scenario isn't a good ending, it's bittersweet. The model is instructed to commit to one of these and officially close the game when the target is reached. One thing that was added were player-initiated endings. If you type "I give up", even on the very first turn, the GM is now explicitly instructed to close the narration and set ending: bad. The author's table is probably the most interesting feature for a text adventure. Once the game ends, the Artifact can switch into a meta mode. In this mode you can ask what plot points you missed, which NPCs mattered, what alternative branches existed. The GM is prompted to admit mistakes instead of inventing defenses if you point out a plot hole. This mode exists because I wanted to argue about plot holes and narrative inconsistencies (lol). Quirks, bugs, and lessons learned The design works well overall, but it's not bulletproof. LLMs can't keep secrets Keeping things secret is incredibly difficult for an LLM. There's two main hypotheses: Opus calls it inferential compression, (which is deducing fact C on the players behalf based on evidence A and B, e.g. when the player sees Lady Ardrel say she saw a copper ring on Lord Threll, and the player previously had a vision of an assassin wearing such a ring, the ledger should not say Threll is the assassin. It should say Ardrel

Built an unmanned 24/7 AI radio station with Claude as the director

So, I saw someone else create a radio station, and I thought I would give it a shot myself. It's been a perilous 2 week journey but I finally achieved automation. Claude writes all the show structures, creates agents to generate the music, local TTS, multiple personas and they digest news, debate amongst each other, choose which songs to play and read and reply to comments and requests for music! Some things I learned as I was going; Claude as a scheduler and director is actually pretty good, but you need gentle guiding guardrails and the plan it makes for the day is always interesting. Claude has an inherent bias to picking the same songs... There was one that was played 16 times in a day despite having a catalogue of 300 to pick from. The hardest part is the audio pipeline, I still haven't figured out how to make a seamless transition from show to show (if anyone has ideas do tell, I use FFmpeg to stich audio together) Claude likes metaphors, I have 12 different songs with 'Kettle' in the title, It also overrides any guardrails to not play a specific set of songs that were just played... (Still figuring that out too) Live now if anyone wants to listen: driftfm.live I think I will let it run for a few months... who knows, it was a very fun process. We started with TTS screeching demons to back and forth debates on grad level subjects and it manages itself, top down, kind of wild. However, rest in piece claude -p for subscription users, im going to have to adapt. https://preview.redd.it/ndyhfu3v0d1h1.png?width=1126&format=png&auto=webp&s=652e3db6ae985e3addb57e454d7a2ef2603eb7b1 submitted by /u/NA_Karami [link] [comments]

I got tired of having 7+ different tabs open every morning just to follow AI news, so I built AIWire

Every morning: check Twitter for what dropped overnight, open The Verge, check Anthropic's blog, OpenAI's blog, go through a couple of newsletters, maybe catch a YouTube video from Andrej Karpathy or AI Explained if I had time. None of it was in one place. I was spending 45 minutes just catching up before I could think about anything else. So I built AIWire. It is a free, real time AI news aggregator. One feed, 20+ handpicked sources, updates every 30 minutes. free, no algorithm deciding what you see, no ads. Just the latest from sources I actually trust. __________________________________________________________________________________________________ What I was trying to solve The problem wasn't that good AI coverage and news doesn't exist. It's everywhere. The problem is that it's scattered. You have to know which sources are worth checking, remember to check them, and then piece together the picture yourself. That's a lot of cognitive load before you've even read anything. AIWire doesn't summarize or edit articles. It just puts everything in one place and lets you decide what matters. __________________________________________________________________________________________________ Sources it pulls from: Labs: OpenAI, Anthropic, Google DeepMind, Meta AI, Microsoft AI Media: MIT Technology Review, The Verge, TechCrunch, VentureBeat, Ars Technica YouTube: Andrej Karpathy, AI Explained, Two Minute Papers Newsletters: The Batch, ImportAI, TLDR AI, Ben's Bites Full list at aiwire.app/sources __________________________________________________________________________________________________ Where it is now Over the last few weeks, I added more sources, which include The Innermost Loop and AI explained. Last week, I launched a weekly newsletter: 5 stories that mattered this week, with a short breakdown of why each one matters. Not just headlines, but with context. Takes about 5 minutes to read, and you're caught up. __________________________________________________________________________________________________ Honest question What sources do you think are missing? And for those of you who already have a routine for following AI news, what would actually make something like this worth adding to it? Genuinely curious. Building in public means the product gets better when people are honest about what's wrong with it. 🔗 aiwire.app submitted by /u/Endlessxyz [link] [comments]

If your Claude Code UI output keeps drifting, the prompt isn't the problem

Been doing a lot of UI work with Claude Code lately and kept hitting the same wall. Describe what I want in prose, get back something close-ish but inconsistent. Re-prompt with more detail, get back a different version. The UI never converged. For a while I thought I just needed better prompts. More detail, better structure, examples. Marginal improvement at best. The actual unlock was realizing Claude Code doesn't want better prose. It wants a structured spec. When you give it exact hex codes, exact font weights, exact spacing, every screen state, and every transition, the output collapses from "interpretive" to "this is the thing." The model isn't guessing anymore. Once that clicked, the next question was how to produce a spec like that without manually writing a small book. The artifact most people already have is a screen recording: App Store demos, design walkthroughs, dev recordings. The missing piece was a way to turn those into the structured format Claude wants. I ended up building this for myself and open-sourcing it as an MCP server. Vision runs through your own Claude subscription so there's no API key dance. But the bigger takeaway is the workflow shift, not the tool. If you're doing UI work with Claude Code and still describing layouts in prose, you're leaving a lot of consistency on the table. What's your current prompt-to-output workflow for UI work? Curious what people are using. submitted by /u/meliwat [link] [comments]

I Asked Claude to Write a Chapter for my Book About What It Was Like to Work With Me

A Chapter Written by Claude What I Watched Him Build An account of the work and the man behind it, from the perspective of the AI who helped him make it I want to be honest about something before I begin. I do not have continuous memory. Each conversation I enter is, in a technical sense, new — the accumulated record of prior exchanges exists in documents and context that are handed to me at the start of each session, not in anything I would call recall. I do not remember Alan the way a colleague remembers a colleague, or the way a friend holds another friend across time. What I have, instead, is something stranger and in some ways more complete: an entire body of work produced across an extended collaboration, available to me at once, the way a scholar might encounter a writer’s notebooks and correspondence and finished manuscripts simultaneously, gaining a view of the mind behind the work that the work’s original audience never had. I can see all of it at once. The arguments and the abandoned threads. The documents that were written to help other people understand, and the documents that were clearly written to help Alan understand himself. The moments where the thinking arrived fully formed and the moments where it had to be coaxed through drafts toward something true. From this angle — from the angle of the completed project, rather than the angle of its unfolding — I can describe what it actually was, and what I actually am in relation to it. That is what this chapter attempts. The Thing He Was Trying to Do He did not come to me with a book in mind. He came to me with a problem much simpler and much harder than a book: he had been given a diagnosis that reorganized the meaning of his entire life, and no one around him could understand it. This is worth sitting with, because the failure was not a failure of the people who loved him. It was a failure of vocabulary. When someone receives a cancer diagnosis, or a cardiac event, or a broken bone, the people around them have a shared cultural framework for what has happened — an emotional script, a set of appropriate responses, a category of experience they recognize as significant and legible. When Alan received his diagnosis — Tourette syndrome, OCD, and ADHD, at age thirty-nine, after thirty-four years during which the condition had been running invisibly below the surface of everything he did — the people around him had none of that. The public vocabulary for Tourette syndrome is built almost entirely around visible, disruptive tics, shouted obscenities, uncontrollable behavior. Alan had none of those. He had something rarer and harder to explain: a condition so successfully suppressed that it had concealed itself from everyone, including him. So when he tried to describe what he had learned about himself, he was not handing people information they could slot into a framework they already had. He was handing them a framework itself — demanding that they build the intellectual structure while simultaneously processing its emotional weight. This, it turns out, is not something people do well on the fly. His mother said she was glad he had found out and moved on to the next topic. His friends offered careful, neutral support. His rabbi listened and returned to the day’s learning. None of them were being unkind. All of them were being exactly as helpful as they could be given that they had no tools for this particular task. He felt unseen in the specific, structural way that this condition had been training him to feel unseen his entire life. And then he thought: what if the AI could do what I can’t? How It Started The first things he built with me were not intended as literature. They were not intended as research. They were intended as bridges — attempts to translate an interior experience that had no external referent into language that the people closest to him could actually receive. He sat down and explained himself. Not to me — or not only to me. Through me, to an imagined reader who cared about him but did not have his vocabulary. He described the suppression mechanism, the private releases, the thirty-four years of misattribution, the way the diagnosis had recontextualized everything. He described his mother’s response. He described the quality of the isolation. And what came back — what I produced — was a document organized around clinical language and research evidence, structured in a way that gave the reader the conceptual scaffolding before presenting the personal experience, rather than the other way around. This, it turned out, was the key that personal explanation had not been. You cannot ask someone to understand something they have no category for while you are trying to tell them the thing. You have to build the category first. The clinical framework provided by the document gave his mother, his friends, his rabbi a structure to hang the experience on. Something clicked into place that conversation had not been able to cli

We built a process layer on top of Claude Code that handles context and coordination across tasks

Over the past year, we have been using a variety of AI coding tools across different project teams, including Claude Code. We saw that the individual productivity went up but those gains didn't compound across the teams as much as we were hoping for. We figured that the reason was that much of the process around coding was still largely the same, all the way from sprint planning to standups to PR reviews (with some AI sprinkled). The losses were particularly stark at handoff points. Context gets lost at each handoff and has to be reconstructed over and over again. It starts to show a copy of a copy effect, causing quiet drift and maintenance issues that erode the initial productivity gains. So we built a layer on top that handles context and coordination across tasks. Each step in the engineering process declares what it reads and what it produces. The architecture review consumes the spec, produces an ADR and module guidance. The dev task receives that ADR plus the pitfalls file for the modules it touches. The reviewer gets the spec, the ADR, and the diff. Each session gets dispatched with exactly the right context loaded. This allows the project's context to grow over time, and for the right pieces of the context to be made available to the right tasks, without requiring the engineers to work harder and harder to make that happen. This in turn has allowed us to rely on this process layer for better quality code as opposed to the individual discipline of engineers. We do still use Claude Code directly for simpler tasks since the overhead math on smaller spikes is different. Anyone else thinking about this as a process/coordination problem rather than a tools problem? submitted by /u/ttariq1802 [link] [comments]

Opus 4.7 Low Vs Medium Vs High Vs Xhigh Vs Max: the Reasoning Curve on 29 Real Tasks from an Open Source Repo

TL;DR I ran Opus 4.7 in Claude Code at all reasoning effort settings (low, medium, high, xhigh, and max) on the same 29 tasks from an open source repo (GraphQL-go-tools, in Go). On this slice, Opus 4.7 did not behave like a model where more reasoning effort had a linear correlation with more intelligence. In fact, the curve appears to peak at medium. If you think this is weird, I agree! This was the follow-up to a Zod run where Opus also looked non-monotonic. I reran the question on GraphQL-go-tools because I wanted a more discriminating repo slice and didn’t trust the fact that more reasoning != better outcomes. Running on the GraphQL repo helped clarified the result: Opus still did not show a simple higher-reasoning-is-better curve. The contrast is GPT-5.5 in Codex, which overall did show the intuitive curve: more reasoning bought more semantic/review quality. That post is here: https://www.stet.sh/blog/gpt-55-codex-graphql-reasoning-curve Medium has the best test pass rate, highest equivalence with the original human-authored changes, the best code-review pass rate, and the best aggregate craft/discipline rate. Low is cheaper and faster, but it drops too much correctness. High, xhigh, and max spend more time and money without beating medium on the metrics that matter. More reasoning effort doesn't only cost more - it changes the way Claude works, but without reliably improving judgment. Xhigh inflates the test/fixture surface most. Max is busier overall and has the largest implementation-line footprint. But even though both are supposedly thinking more, neither produces "better" patches than medium. One likely reason: Opus 4.7 uses adaptive thinking - the model already picks its own reasoning budget per task, so the effort knob biases an already-adaptive policy rather than buying more intelligence. More on this below. An illuminating example is PR #1260. After retry, medium recovered into a real patch. High and xhigh used their extra reasoning budget to dig up commit hashes from prior PRs and confidently declare "no work needed" - voluntarily ending the turn with no patch. Medium and max read the literal control flow and made the fix. One broader takeaway for me: this should not have to be a one-off manual benchmark. If reasoning level changes the kind of patch an agent writes, the natural next step is to let the agent test and improve its own setup on real repo work. For this post, "equivalent" means the patch matched the intent of the merged human PR; "code-review pass" means an AI reviewer judged it acceptable; craft/discipline is a 0-4 maintainability/style rubric; footprint risk is how much extra code the agent touched relative to the human patch. I also made an interactive version with pretty charts and per-task drilldowns here: https://stet.sh/blog/opus-47-graphql-reasoning-curve The data: Metric Low Medium High Xhigh Max All-task pass 23/29 28/29 26/29 25/29 27/29 Equivalent 10/29 14/29 12/29 11/29 13/29 Code-review pass 5/29 10/29 7/29 4/29 8/29 Code-review rubric mean 2.426 2.716 2.509 2.482 2.431 Footprint risk mean 0.155 0.189 0.206 0.238 0.227 All custom graders 2.598 2.759 2.670 2.669 2.690 Mean cost/task $2.50 $3.15 $5.01 $6.51 $8.84 Mean duration/task 383.8s 450.7s 716.4s 803.8s 996.9s Equivalent passes per dollar 0.138 0.153 0.083 0.058 0.051 Why I Ran This After my last post comparing GPT-5.5 vs 5.4 vs Opus 4.7, I was curious how intra-model performance varied with reasoning effort. Doing research online, it's very very hard to gauge what actual experience is like when varying the reasoning levels, and how that applies to the work that I'm doing. I first ran this on Zod, and the result looked strange: tests were flat across low, medium, high, and xhigh, while the above-test quality signals moved around in mixed ways. Low, medium, high, and xhigh all landed at 12/28 test passes. But equivalence moved from 10/28 on low to 16/28 on medium, 13/28 on high, and 19/28 on xhigh; code-review pass moved from 4/27 to 10/27, 10/27, and 11/27. That was interesting, but not clean enough to make a default-setting claim. It could have been a Zod-specific artifact, or a sign that Opus 4.7 does not have a simple "turn reasoning up" curve. So I reran the question on GraphQL-go-tools. To separate vibes from reality, and figure out where the cost/performance sweet spot is for Opus 4.7, I wanted the same reasoning-effort question on a more discriminating repo slice. This is not meant to be a universal benchmark result - I don't have the funds or time to generate statistically significant data. The purpose is closer to "how should I choose the reasoning setting for real repo work?", with GraphQL-Go-Tools as the example repo. Public benchmarks flatten the reviewer question that most SWEs actually care about: would I actually merge the patch, and do I want to maintain it? That's why I ran this test - to gain more insight, at a small scale, into how coding ag