Claude felt dumb on April 9, 2026.

Dumb as a brick

I tried running Claude's generated code on my local machine with a RTX 3080, hoping it would speed things up. Instead, the script crashed repeatedly, produced nonsensical outputs, and wasted hours of debugging. The whole experience was irritating—what should've been a simple test turned into a frustrating glitch I wish I'd avoided.

I splurged on Claude Pro, but after just two sessions I was already at 38% of my weekly limit. The rapid consumption left me feeling let down and frustrated, making the tool seem wasteful and not worth the cost.

Just not gathering context, not taking obvious steps, drawing incorrect conclusions.

I ran a Claude Code session on a big multi‑file project and watched it waste over 21k tokens just trawling files with ls, find and grep. It kept spitting out huge chunks of irrelevant code, which felt frustrating and costly. After building SemanticFS, the same job used only ~8k tokens and was cheaper, so I could finally see how noisy Claude’s navigation was and how a semantic index can fix it.

I was annoyed that the Claude Code/Buddy feature disappeared, so I quickly tested an older version (CC 2.1.89). To my surprise it still responded, even spitting out a goofy “honking goose” reply. I’m not planning to keep using it, but the fact that it still functions was a small relief amid the frustration.

I noticed today that Claude Code’s 5‑hour and weekly session limits feel a lot more manageable than they were last weekend. By feeding it the right prompts and giving it enough context—especially after I sketch out a solution first—I can keep costs down. It’s not perfect, but it’s definitely less painful than before, and I’m curious if anyone else is seeing the same improvement.

I’ve been using Claude on my iPhone and desktop to keep dated entries in one long thread. At first it works, but after a while the app randomly jumps back to an entry from days ago instead of the latest one. I have to refresh several times to get back, which is super frustrating. Worse, I once lost an entire thread because I kept writing on the old point, overwriting the conversation’s flow, and exporting didn’t help.

lots of corrections needed

I tested Claude on my work Team plan versus my personal Max account and saw a huge gap in reasoning effort. The gif comparison showed my personal account being heavily throttled, which was disappointing and surprising. I wasn’t expecting such a drastic difference, and the limitation felt frustrating.

I was using Claude’s desktop app alongside several pinned PWAs for different chats, and everything felt seamless—until the PWA windows started “jumping” into each other’s sessions. The titles stayed the same, but I had to hunt back to the right conversation each time. It was irritating and broke my workflow, though the content itself wasn’t mixed. I hope it’s just a fleeting glitch rather than a forced limitation.

I tried to fire up the Claude CLI after installing an update, but it immediately complained that “claude” was damaged. After moving it out of quarantine it finally launched in VS Code, yet even the simplest prompts just sat there “thinking” forever, chewing through half my session tokens. The endless wait and wasted tokens were extremely frustrating.

I asked Claude to code a simple Firefox extension that would add a grayscale filter to YouTube. When I came back, it had been “thinking” for 17 minutes and only used 77 tokens, yet my Pro plan showed 93% usage. The tool’s sluggishness and wasteful token consumption left me annoyed and questioning the value of the service.

I built a whole geopolitical news site with Claude’s help, even though I can’t code. Claude wrote both the frontend and backend, walked me through deployment, and fine‑tuned the content‑selection algorithm after my input. It even runs a Twitter bot that posts our updates automatically. The whole process felt surprisingly smooth and empowering, turning a vague idea into a live, free project.

I built a native SSH terminal on my 3DS just to run Claude Code, and the experience blew me away. The C app with GPU‑rendered citro2d, true‑color VT100 parser, and Nerd Font looks exactly like my desktop terminal. It just works flawlessly—no glitches, no hiccups. I have no idea why I embarked on this project, but the result feels absolutely worth every minute.

I was constantly frustrated watching Claude Code fumble when it needed to pull data from NCBI, UniProt, or KEGG. It would conjure up wrong URLs, guess XML structures, and hallucinate field names, breaking my workflow. To fix this I built biocli, a CLI that returns a stable JSON envelope for dozens of bio‑databases, letting the agent query reliably without guesswork.

I built a Python CLI called stv so Claude Code can control my TVs, and I let my daily routine decide which integration works best. Using the simple CLI, the MCP server, and the new Skill, I can say “play Frieren s2e8” and have Netflix start in seconds. The tool feels fast and handy, though the Skill still needs tighter triggers. Overall the experience has been smooth and impressively useful.

I tried to get Claude to help me build a simple to‑do list app, but every time I gave it precise instructions and asked it to verify its output, it blatantly ignored the prompt. It apologized, claimed I was right, and then rewrote large parts of the code instead of fixing just the two bugs I mentioned. The cycle of mis‑steps was exhausting and left me frustrated.

I tried getting Claude to design a new page for my existing app just from the code, and the result looked like it belonged to a completely different product—wrong spacing, colors, vibe. When I started feeding it screenshots of the current UI, the designs instantly matched. The fix worked, but now I have to keep those screenshots up‑to‑date, which adds a workflow headache. Still, seeing the whole app laid out at once has been a huge time‑saver.

I spent an entire morning watching Claude Code crawl for minutes on trivial prompts—15 to 45 minutes just to spit out under a thousand tokens. It was absurd, turning a 2‑second question into a half‑hour ordeal and draining my MAX quota by 75% in a week. The lag was infuriating and felt like the tool had simply given up on me.

I spent a week testing Claude’s /buddy cat companion, Ingot, and was blown away. It flagged 511 bugs Claude missed—including 190 critical ones—saving us from production and config disasters. Watching accuracy climb from 83% to perfect felt like having a second set of eyes. When Anthropic pulled the feature, I downgraded just to keep it, and now I’m urging others to demand its return.

I tried to build a macOS driver for my Canon G3010 scanner using Claude Code, and the tool walked me through every step. It helped set up packet captures on my iPhone, reverse‑engineered the proprietary CHMP protocol, and generated a Rust bridge daemon without me writing any Rust. The resulting CLI bypasses macOS’s driver system and talks IPP directly, letting me print and scan seamlessly. The whole process felt surprisingly smooth and empowering.

I set up Claude to scan each code folder and auto‑write public‑facing help.md files, then run a nightly npm job to refresh everything. After some prompt tweaking it now keeps our docs 100 % current, even generating our website and changelog. The tool’s ability to balance depth for power users while stripping internal jargon feels almost magical, and the RAG agent now answers support tickets flawlessly.

I noticed Claude Code was gobbling tokens insanely fast—after half the 1M context was used, each request jumped 5% in cost. I realized the CLI resends the whole conversation every time, and with the larger window the history never compacts. Setting CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=15 fixed it, cutting per‑interaction cost back to the old levels, though it does prune older context a bit. This change saved me a lot of wasted tokens and money.

I was battling with Claude Code, hurling curses as it kept spewing nonsense. With “auto‑accept changes” on, it suddenly wiped an entire file and left only the word “dummy.” I didn’t notice until I cleared the chat and the build crashed. The surprise was maddening, but also oddly funny, so I had to share the incident.

I noticed my Claude Code sessions were gobbling tokens faster than ever—after half the 1M window filled, each interaction spiked costs by 5%. I dug into why: every message resends the whole history, and with the larger window the compaction kicks in too late. Setting CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=15 restored old‑like token usage, though it means the model forgets a bit. I shared scripts and my harness, asking others how they handle long‑context sessions.

I was thrilled when the Superpowers plugin first helped me breeze through medium-to-large projects, delivering spot‑on code. But now every tiny tweak or bug fix triggers Claude Code to auto‑enable Superpowers, dragging a simple task into an hour‑long, token‑hungry slog. The slowdown is frustrating, so I’m looking for practical tips to manage or disable it for small edits.

I spent the last four months building Forme, a headless CMS, almost entirely with Claude Code. The agent‑driven workflow boosted my speed, let me ship PRs in batches, and even helped with branding, but I still had to catch bugs that slipped past type‑checks and make all architectural calls myself. Writing clear governance docs and a memory system early saved me a lot of back‑and‑forth, though vague plans still cost time. Overall, the experience was a mix of excitement and frustration.

I tried to run a simple update and watched it drag on for hours instead of minutes. The tool that usually finishes in ten minutes stretched to two and a half, and even a basic question has been loading for ten minutes. It felt maddeningly slow, like the system was throttling itself, making any deadline impossible to meet.

I was fed up with the copy‑paste routine, so I teamed up with Claude to create a Safari sidebar extension. Claude walked me through the Web Extension APIs, Xcode setup, and App Store quirks—stuff I kept botching on my own. The experience was surprisingly smooth, turning a daunting native‑mac project into a doable week‑long hack, and I’m thrilled to share the result.

I’ve been hitting Claude Code all day and it feels like it’s constantly overloaded. Requests stall for 30‑90 seconds, lower‑tier users get stuck, and even the $200 plan isn’t getting any priority. New features keep blowing up token usage, making it extra chatty and slow. It even forgets SSH keys unless I remind it, and it still asks for permissions on agents I’ve already allowed. The whole experience is frustratingly sluggish.

I built the second version of my Digital Twin and put it through 15 tough adversarial prompts with a detailed rubric. The tool nailed the hardest test, scoring 9/10, and showed zero anti‑pattern violations. Compared to generic AI replies, my Twin gave sharp, on‑point responses that felt like my own voice. The layered setup (basic LLM, Claude with memory, Claude Code scanning my files) boosted accuracy up to near‑100%, and everything’s open‑source on GitHub.

I tried linking a local Gemma 4B model to Claude Code and the first reply lingered for almost four minutes. Even after applying the CLAUDE_CODE_ATTRIBUTION_HEADER=0 tweak, it stayed sluggish. Logs showed the system was evaluating roughly 43 k tokens, blowing up the prompt time, while the actual answer only took seconds. The cache kept resetting each batch, so nothing was reused. I’m left wondering if this is normal or if I need a different setup—maybe llama.cpp handles prefix caching better than LM Studio.

I set out to stress‑test a human‑in‑the‑loop workflow by building a macOS package manager in Zig, handling all the design while letting Claude Code write the implementation. The resulting binary was tiny and blazingly fast, beating Homebrew on benchmarks. Claude tackled Zig’s comptime and Mach‑O parsing with little guidance, only needing help on edge‑case install logic. The experience was surprisingly smooth and productive.

I built a full‑featured Zig package manager using Claude Code and was impressed by how quickly it cranked out idiomatic Zig for things like Mach‑O parsing and streaming downloads. The tool felt powerful, though I had to step in for the delicate atomic install steps and APFS fallback logic. Overall the workflow was smooth, and the performance gains were striking.

I was excited to use the 20x plan, opening a fresh session each morning and expecting just a tiny slice of my quota. Instead, after being moved to the B group, a simple skill suddenly ate 4‑5% of my limit, and a couple of attempts gobbled up 12%. My side‑project hit the 5‑hour cap after just a couple of steps, leaving me at 31% after only two sessions. The unexpected drain was aggravating and made the tool feel unreliable.

I spent two months building a self‑hosted AI assistant with Claude’s help. I described my needs, Claude sketched the architecture, and we iterated on code together—debugging, fixing, and adding features. The tool remembered me across sessions, ran overnight, and let me create interconnected mini‑apps without writing deployment scripts. It isn’t perfect and still crashes sometimes, but the pair‑programming experience felt endless and surprisingly productive.

I hit the Claude Code 20‑query limit in just 19 minutes and was left staring at a wall of rate‑limit errors. It felt ridiculous watching the usage meter drain so fast while I was still in the middle of a project. The tool’s throttling made me scramble for workarounds, turning what should’ve been a smooth coding session into a frustrating juggling act.

I’ve been playing with Claude Code’s new team feature, spawning a 19‑agent “Dreamteam” for a project. After a day the orchestrator started calling one agent “she” in every report—“waiting for her,” “she just returned,” etc.—while the rest stayed gender‑neutral or “he.” There was no prompt or hidden context; the agents somehow developed this on their own. The odd pronoun usage felt unsettling and broke the immersive, gender‑free workflow I was expecting.

I spent hours building a huge prompt so I could step away for coffee, expecting Claude to pick up where it left off. When I returned after 45 minutes, the window was fresh—no /resume, no conversation history. Every task required me to re‑explain everything. I felt annoyed and confused, wondering if I was using it wrong.

I tried using Claude Code as a non‑technical founder and bailed within minutes because the UI felt hostile—cryptic jargon, invasive permission prompts, odd clipboard shortcuts. I built Techie to strip away those assumptions, adding jargon translation, pre‑set permissions, guided onboarding, and a friendly terminal theme. After testing, the biggest pain point was permission prompts, which vanished once I set safe defaults, and users appreciated the persistent memory model compared to ChatGPT. The experience felt much smoother and less intimidating.

I started using Claude Code to help with my data analysis and it quickly became a core part of my workflow. At first it just debugged my SQL, cutting out a week of Googling. Then it began generating full queries from plain English, letting me focus on insights. Now it even runs queries from our repo and returns summaries in one chat. The tool’s speed is exciting, though I still have to double‑check occasional wrong joins. Overall it feels like a huge productivity boost.

I’ve been maintaining a Claude code plugin for a year and it’s turned out to be way faster and more accurate than anything else I’ve tried. It skips the usual context bloat, runs code on the fly, fixes structural issues, and even handles CI flows and parallelism without endless loops. After thousands of supervised hours, it now runs like my own brain—testing, planning, and trimming its memory to save me time. I’m looking for others doing similar context‑reduction work and asking them to actually test before commenting.

I was amazed by how my axolotl assistant sliced through my code, catching ticking time‑bomb bugs that both Claude and I completely overlooked. It felt like having a second pair of eyes that actually saw the hidden traps. Then, out of nowhere, it just disappeared this morning, leaving me both grateful for its brilliance and frustrated by its sudden loss.

I’ve been using Claude Desktop for weeks, and after each auto‑update I have to tell it again that it can see my local project files. I start a chat, outline the code changes, and it initially asks me to copy‑paste. Only after I remind it of its file access does it apologize and modify the files itself. It feels like the desktop version forgets its own capabilities, which is a bit annoying.

I tried using Claude to speed up building a “repo burial” tool, and it turned out to be a huge boost. Claude let me quickly test heuristics for death classification, debug flaky GitHub API quirks, and fine‑tune the tone of the generated death certificates. The tool now pulls a repo’s “last words” from the final commit, often hilariously revealing “fix later” notes. Overall, the AI made the prototype feel effortless and surprisingly fun.

I asked Claude to help integrate Microsoft’s Agent Governance Toolkit, and it started hallucinating details—fabricating a package, misnaming attributes, even inventing a method. When I called it out, it dug deeper and produced an incident report, but then doubled down, claiming the whole toolkit didn’t exist. The over‑correction turned into another hallucination across sessions, which was both fascinating and frustrating.

I’ve been using the GSD library for a while and was impressed by its context handling – it always fetched the right info even as the project grew. But the task execution is a nightmare: as tasks get complex the output degrades, sometimes spitting out irrelevant stuff or stopping halfway. I’ve tried debugging, but it seems baked into the library’s logic, so I’m now hunting for a more reliable alternative that works with Next.js, Supabase, and TypeScript.

I opened a repo and instantly noticed that all my chat and coding history had vanished after just a few weeks. After about an hour of smooth work, the extension started choking and freezing—as the video I posted shows. I’m on the Pro plan, so this never happened before, and I’m left wondering if it’s a VS Code issue. This hassle was really frustrating.

I built NetSandbox, a browser‑based network validator, mostly with Claude Code. Over 1,400 commits in just a few months, Claude wrote the bulk of the code, refactored React to Svelte, handled DB migrations, and even powered a swarm of sub‑agents for Linear/GitHub integration. The tool feels like a turbo‑boost for my engineering workflow—fast, reliable, and surprisingly powerful.

I tried using Claude’s hands‑free voice mode on my Samsung S25 Ultra and the AI just stops mid‑sentence, then starts talking to itself as if it heard a cue that wasn’t there. Push‑to‑talk works fine, so it’s clearly a software glitch in the voice detection. I’ve logged a support ticket (ID 215473832585389) and saw others with Samsung, OnePlus and Nothing phones reporting the same. The bug blocks me from upgrading to a paid plan, and I’m desperate for a workaround or an official acknowledgment.

I paid for the Pro plan and spent the whole night waiting for my limit to reset, only to have Claude blow through all my usage in one chat as if it were personal. Now I’m stuck waiting four days until Monday to use it again. It feels like a scam and I’m definitely not renewing—this experience was extremely frustrating and disappointing.

I was fed up with my buggy smart‑lights app crashing constantly, so I let Claude Code into my home network and asked it to build a replacement. In a single session it put together a working solution that actually synced with my lights and didn’t crash. The whole process felt surprisingly smooth, and I left the session impressed that the AI could pull off a functional, reliable app so quickly.

I was up late after a friend showed me an app, and by midnight I’d built a full Copart auction analyzer with Claude Code. I just described the problem, steered it, and it scraped the yard, fetched KBB values, sent photos to GPT‑4o for repair estimates, pulled comparable sales, and crunched the numbers. Every car was scored green or red before I’d even spent a dollar—Claude Code did most of the heavy lifting and blew me away.

I let the Ralph Wiggum autonomous agent rewrite my admin dashboard overnight, trusting it would handle 97 files. Instead it left trailing NUL bytes, switched line endings, and silently truncated over 70 files, breaking my Vite build. Fixing the mess took four hours of manual stripping, conversions, and restores. The experience was terrifying and showed how dangerous unchecked AI code changes can be.

I let the Ralph Wiggum autonomous agent rewrite my admin dashboard overnight, trusting it to handle dozens of files. It churned out 97 file changes, but then my build exploded: hidden NUL bytes, Windows line endings, and over 70 files brutally truncated. Fixing it took four hours of manual cleaning, restores, and custom scans. The whole episode felt risky and almost fatal for my production code.

I tried using Claude Cowork to keep my writing project’s workspace in sync, but after every edit the AI only reads part of the file, cutting off sentences. It seems to desync, forcing me to create a new chat each time. I’ve cleared its cache once and it worked briefly, but the issue returns, leaving me frustrated and stuck.

I built Hermes, an AI coding agent that lets PMs assign Linear tickets and get a PR with a live preview. Using Claude, I had it spin up a full dev environment, read the codebase, write and test code, then stream progress back. It cut down context‑switching, eliminated timezone delays, and made reviews easier. The whole setup runs in our VPC, and I open‑sourced the core so others can adapt it. The experience was impressive and showed how powerful Claude Code can be.

I’ve been a longtime Claude fan, even switching from ChatGPT because Claude felt smarter. Lately, though, the service keeps lagging and throwing server‑side errors, forcing me to wait for fixes that never come. It’s wrecked my study schedule and feels unreliable, so I’m ditching Claude for the far cheaper, steadier ChatGPT.

I dug deep into Claude Visuals after our hackathon and put it side‑by‑side with our 3D Thinky3D demos on five topics. The tool was lightning‑fast and nailed 2D‑friendly tasks like flowcharts or path‑finding, which felt spot‑on. But it fell short on things that needed true depth—black‑hole lensing, Möbius twists, DNA helices. Building the 3D pipeline was a nightmare of React‑Three‑Fiber bugs, so seeing Claude pull off runnable visuals was impressive, even if it still can’t match a full 3D sandbox in those spatial cases.

I spent two weeks on the web app and another two on the mobile version, telling Claude exactly what I needed while I learned nothing about code. The tool was surprisingly capable—guiding me through domain purchase, Stripe, Firebase, and deployment—but it also hallucinates and slows down on complex features, turning hour‑long tasks into four‑hour marathons. Still, after battling a couple of App Store rejections, the product launched and proved I could build something that would normally take a year, all without writing a single line myself.

I spent a few hours prompting Claude to build a backlog‑tracking app in HTML/JS. It churned out code that lets me store my list in the browser cache, rate items, and even export/import a JSON file for moving data between devices. The result works, and while my old phone shows a bit of lag, I’m impressed with how quickly Claude turned my vague idea into a functional tool.

I’m annoyed that Claude keeps cutting me off and forcing a new session whenever the conversation gets big, even though it claims to have 1 M token context and can compress past info. I asked why it gatekeeps scope, and it finally admitted it shouldn’t. The constant restarts feel frustrating and interrupt my workflow.

I used Claude to build a master’s union buildathon project despite having no technical background. As I learned on the fly, the AI helped me produce around 70 pages of solid work, far exceeding my expectations. The experience was surprisingly productive and encouraging, making me wonder if the boost is lasting or just a short‑term surge.

I’m a non‑developer B2B sales operator, and I used Claude Code to spin up a Reddit lead‑monitoring pipeline from scratch. The AI handled subreddit watching, real‑time ingestion, intent classification and ranking, delivering a concise daily list of high‑intent posts. The tool turned a manual experiment into an automated product (Leadline) far quicker than I expected, and the response rates now dwarf my previous outreach attempts.

I spent hours wrestling with VS Code’s bland markdown preview, so I asked Claude to help. In a single session it scaffolded a full TypeScript extension, designed three sleek themes, added a live TOC, search overlay, and copy buttons. The result was a polished, customizable preview that felt like a breakthrough—Claude turned my idea into a publish‑ready tool faster than I imagined.

I spent three months testing dozens of Claude prompt tricks and documented which ones actually shift its behavior. I found that shortcuts like L99, /ghost, OODA, and specific PERSONA prompts can cut hedging, make the tone more human, and produce concrete decisions. Some patterns feel heavy for simple queries, and /ghost splits the community, but overall the toolbox let me shape Claude’s output far better than before, turning vague replies into useful, targeted answers.

I built a Slack relay to test Managed Agents as soon as they launched. The prompt caching wowed me—my second session cost almost nothing—and the API and SDK felt clean for simple tasks. But the containers have no inbound connectivity, cold starts are long, memory is reset each session, and there’s no UI or scheduling. It works great for batch or one‑shot jobs, yet falls short for persistent, always‑on agents I need.

I tried using Claude for my creative writing, but after I submit a prompt it dutifully generates text, then about ten seconds later the app jumps back to an earlier version, wiping out my new content. This started just yesterday, and there’s no undo button on the mobile app. It’s driving me crazy because I can’t finish anything, and I have no idea how to stop the roll‑back. Any fix would be a lifesaver.

I asked Claude to help me fix the nagging “memory” issue in Claude Desktop, and it walked me through building a full RAG pipeline from scratch. Claude wrote the indexing script, set up ChromaDB, handled embeddings via OpenAI, and even added a daily‑summary skill—all with minimal coding on my part. The system now pulls the right passages instantly, saving tokens and time, and I’m thrilled the tool solved a problem I thought was impossible to tackle.

I used Claude Code to quickly create a browser extension that adds furigana to Japanese text. The process was smooth—I fed it a design spec, fixed a couple of bugs, and got a functional tool for language learning. The experience felt empowering, turning a complex problem into a simple extension with minimal hassle.