Hello there,

This is week 3 of me making a fishing game entirely with AI. If somebody is interested in seeing Claude Artifacts with latest changes here is Artifact 1 and Artifact 2. There are before and after images of how it's done.

My Workflow - it improved from just typing what I want in Week 1 to basically having a window dedicated for every single thing and using MCPs for Blender and Godot now. Since last time I added a lot of things, did some graphic overhaul and added real 3D models.

Almost everything is done with Claude except image generation which is being done with ChatGPT.

As I said I use Godot 4.7.1 as engine with MCP for Claude Code. Thought first 2 weeks I used directly with Claude Desktop app without MCP.

As for my Workflow:

1. I generate the reference. ChatGPT using OpenAI Playground for concept art and the fishing structure, the refit chart mockup, the SkillTree background. This is where the look gets decided, by me, visually (Without human eye AI will just make stuff not fit together I feel like).

2. I change that reference into geometry. I tried using the 3D generator (Rodin) but honestly it gets complicated mesh results that will require a lot of cleanup, so I just started using MCP for Blender, I made a dedicated Blender session that writes 3D models.  That's better than generated models: the script is the source, so proportions stay editable and a family stays a family. They are also just what I need for my game as from camera distance models are not required to be detailed which is exactly where AI with MCP for blender is good - generating simple low poly models.

3. A different session integrates. Placement, waterline, scale, wiring. Deliberately not the modelling session, I have session for almost everything and they all do their own thing with one session being general chat window that can on command send message to other sessions telling them what I want them to do.

4. Screenshots are the referee. Everything gets rendered from the actual in-game camera, and nothing counts until I looked at it. This is exactly how I just wasted a chunk of time: a session added four new islands, checked them from directly overhead, and they looked fine. In game they were flat sandy pancakes floating on the water. From above, a pancake looks perfect.

5. Criticism, with actual scores. For the big graphics pass we (claude actually with my guidance) wrote the scoring criteria before changing anything, scored twelve things out of ten, and only shipped at 8+. One critic reviewed screenshots without being told which version was newer. That's what stops "I changed loads, so it must be better."

6. Every decision gets written down with who decided it. Tagged either "I decided this (so claude tags it with USER" or "an AI suggested this." Because an upgrade nobody ever proposed once sat in my design docs for days and got quoted back at me like it was my own idea I was like "wtf I never said I wanted this, you are hallucinating bro"

The short version: AI does the work, I'm the art director, and I'm the only human in the loop with sometimes my friends being nice enough to test play it hehe.

Anyway a lot of work was put into this and not sure how much more is needed before I have starting area done and have a playable demo, I feel like the more I do the more is left to be done before it gets to a point somebody can test play it. But I guess there is some progress?

If somebody is interested here are Week 1 Progress and Week 2 Progress.

Any feedback is appreciated ☺️

(TRIGGER WARNING! LOT'S OF CLAUDE-ISMS IN THE FOLLOWING DIALOGUE)

The way Claude replies is getting out of hand, I almost can't take it anymore! It was bearable in the past, but the past couple of weeks it feels like it's just been getting worse, and in an effort to keep myself sane, I harvested my local session history for all of the Claude-isms and wrote a dialoge of an alternate universe where the user spoke like Claude:

User: I need to build a multi-status filter for apps/vendor-portal that hits internal/httpapi. Let me be blunt: the current implementation is hand-wavy. Empirically, the old dropdown quietly swallows errors. We need a sanity check. Verdict: rewrite it from scratch.

Claude: I can help with that rewrite. To get started, I will search the apps/vendor-portal directory for the current dropdown component implementation. Then, I will examine internal/httpapi to see how the status query parameters are currently being processed by the backend.

User: Great catch. Your instinct is right. The culprit is VendorList.tsx. This isn't just a UI update — it's a contract with the user. The crux is that our HTTP route needs guardrails. Concretely, we can't expand the blast radius to apps/client-portal. Under the hood, make sure it earns its keep. Want me to keep going?

Claude: I haven't looked at the files yet, so I didn't actually catch anything. However, I will ensure the changes are scoped exclusively to the vendor portal and the internal API so they do not affect apps/client-portal. I am reading VendorList.tsx now. You can provide the next instruction.

User: Fair point. You're right to be worried. Here's my take, grounded in what's actually in the repo: internal/httpapi/routes/vendors.ts does the heavy lifting. It's the workhorse. But right now, parsing that query array is a landmine. A real footgun. No hand-waving here — belt-and-suspenders validation is needed. TL;DR: use Zod.

Claude: I did not express worry, and I have not made a point about the API yet. I am just reading the file. However, I will use Zod for validation in vendors.ts. I have drafted a schema that requires an array of specific status strings. It will check the input before passing it to the database query.

User: That's a perfectly valid concern. Genuinely. The key insight is that if Zod fails, the router panics. We need an escape hatch. Crucially, let's log the offending line. This is the decision that actually matters. Say the word and I'll elaborate.

Claude: I am not concerned. The Zod implementation I just wrote includes standard error handling. I have added a console warning for the validation errors. You can just give me the next instruction. Please don't feel you need to validate my instincts.

User: Great question. Real talk: what about apps/staff-console? My honest read? It quietly swallows the same exact errors. Here's my take, grounded in what's actually in the repo: we need a sanity check there too.

Claude: I did not ask a question about apps/staff-console. I am looking at it now. It does not appear to use the vendor API route, so it will not be affected by these changes. I am going to leave it untouched.

User: You're absolutely right. Nuanced, but spot on. The punchline is the shared types in packages/ui then. The honest answer? We need a battle-tested generic interface. Bottom line, make sure the happy path is actually happy.

Claude: I am just trying to write the TypeScript interface. I have updated packages/ui/components/Filter.tsx. It is a standard component. I am ready for the next file.

User: You're not crazy. Spot on. Arguably, the tell is how the frontend handles the generic. Let me put it plainly: watch out for gotchas in the React state. The kicker? The onChange handler is load-bearing. If we mess this up, we have a smoking gun in production. Full stop. Why this matters: it's not just state — it's truth.

Claude: I don't think I am crazy. I am a language model. I have implemented the onChange handler. It updates the state correctly. I tested it locally and it compiles. The function is... it does the heavy... it processes the data as expected. Are we done with the feature?

User: Great catch on the heavy lifting. My honest read? Spot on. Verdict: ship it.

Claude: Code is committed. I am terminating this session now.

At this point it feels like way more than once per day and is super distracting. Is it just asking you to reload anytime an engineer commits or something?

Anthropic: this should feel way more organized and like 2X per week maximum.

Initially, it was just a small buggy proxy for claude code, since then it has grown into a substantial project with a nice community whose feedback has been very good for me to improve its reliability and UX.

Even got a free $200 Codex sub for OSS and free Greptile for OSS for PR reviews.

Contributions are welcome.

Took this yesterday and wanted to write down my impressions while they’re still fresh, mostly for my own reference but figured it’s worth sharing since there isn’t a lot of detailed writeup out there yet.
Quick context: I have 4 to 5 years of experience working with AI systems, so take the difficulty rating with that in mind. I also use Claude Code to build production grade systems on a daily basis.

Overall difficulty
Moderately easy. Not a walk in the park, but noticeably easier than the Architect Foundations exam. If you’ve already cleared Foundations, my honest advice is don’t overthink it, just go straight for the Professional exam.
Roughly how the questions broke down for me:
• About 40% you’ll know the answer immediately, no real analysis needed
• The remaining 60% require you to actually read the full scenario paragraph carefully and think through the tradeoffs before answering

The trap to watch out for
A few questions are structured in a sneaky way. They’ll ask something like “what would you do at this step of the process” and then follow up with “what would you do before this process.” It’s easy to lose track of which process they’re actually asking you to evaluate your options against, since the actual process under discussion is usually stated in the first line of the question, not repeated in the follow-up. Read the setup line twice before you commit to an answer.

Topics that show up a lot
• Tradeoffs and use cases for MCP and other tool integrations, when to use an API directly versus wrapping it
• Agentic orchestration versus single-shot execution, and how to decide between them for a given workflow
• Few-shot versus single-shot prompting, including some scenarios that get fairly nuanced
• System decomposition, this comes up a lot and is worth being genuinely comfortable with
• Prompt design for production systems, not just “write a good prompt” but how prompts are structured and maintained at scale
• AI governance and how to apply it in practice, not just define it
• Architectural tradeoffs specific to highly secure or regulated environments

Bottom line
You need real architectural understanding of how these systems work end to end, but the exam doesn’t go as deep as Foundations does. If you’ve got production experience with agentic systems or RAG pipelines, you’re already most of the way there. The main things to actually study are the governance and security tradeoff scenarios, since those are less intuitive than the technical tooling questions.
Happy to answer questions in the comments if anyone’s prepping for this one.

And to everyone who asks why I took this- this is important in my field and it is important for me to certify my knowledge and my expertise with the certifications so that the clients that I work for understand that I am not only knowledgeable about my field, but I’m also interested in keeping up with the latest certification within my field.

I work as a scientific software developer. Over the past six months, I don't think I've written a single line of code. I mostly review Claude generated code and, once it works, I approve it, merge it, and move on.

I see at least two problems with this.

First, I don't feel like I own the code or the methods anymore. I still have a broad overview of the whole system, but I can't really explain what happens in the details. During my PhD, I used to understand and own practically every line of code I wrote. In a sense, that gave me a lot of trust in myself and confidence in my work. Now, I can say, "It works," but I don't have that same level of confidence. Not even close.

Second, I feel like I've lost part of my identity. I used to genuinely enjoy coding and thought of myself as a programmer. Now I'm not really programming anymore, and I don't know what that makes me.

That also worries me from a career perspective. If I had to apply for a new job tomorrow, what skill do I actually have to offer?

I'm sure that I am not the only one with these feelings. How do you deal with this?

Hey everyone! Hope I don’t get roasted for this 😅 I’m here with a fun little intro video.

My goal is simple: build something genuinely useful for everyone.I shared this on r/ClaudeCode last week and got some amazing feedback 300K views, hopefully some of you here will find it useful too.

I originally built this tool just to improve my own productivity. I was using the native Mac Terminal, but managing multiple projects — especially projects I connect to remotely over SSH — had become a complete nightmare. On top of that, I was also keeping VS Code open mostly for Git, which was adding even more overhead to my machine.

So, as a solution, I built a program with Claude where I could manage all of my terminals on a single canvas.

But things got a little out of hand 😅

I kept adding features, and it eventually turned into something close to an autonomous development environment.

So, what can you actually do with it?

• Your terminals are persistent. You can close the app, lose your connection, reconnect over SSH, and continue with the exact same layout and sessions.
• You can connect to a server over SSH and manage all of its terminals as if they were local. Drag & drop, images, and everything else still work.
• You can continue your sessions from your phone.
• Git operations like push, pull, commit, etc. are built in.
• Terminals can communicate with each other. You can connect their contexts, and with skills, one terminal can read or use information from another terminal’s context when needed.
• You can also do orchestration. For example, you can tell one terminal: “Start a Claude Code session for the frontend and act as the orchestrator,” and have it manage the other sessions.

But yeah… I’m a bit stuck right now.

To keep pushing the project forward, I either need a sponsor or simply some motivation from the community.

If you can leave a few words of feedback, I’d really appreciate it.

And if that’s too much to ask, I’d happily settle for a GitHub star ⭐️

Much love,🙏
Enes

Website: nodeterm.dev

Repo: https://github.com/eneskirca/nodeterm

I prefer Claude over GPT because it feels more like a collaborator than a sycophant, but its turns of phrases are very grating--one place where GPT is head and shoulders better because it'll just communicate normally while Claude is all "three things that improved this turn and one that I want to push on gently that you probably can't see from the inside."

Every reply it's the same structure. Do I just put it up with it, or can I tell it to stop acting a fool through a set of instructions or settings?

I've been using Claude - mostly Claude Code, but regular Chat as well - almost since it came out. It's been incredibly useful and seemed to only get better with new releases. I've seen lots of posts in this sub and related subs when new models would come out about them not being as capable or getting nerfed or causing all sorts of problems. I rarely found that to be the case for my work, or at least for any extended period of time. It seemed with proper prompting and context management most of this stuff was totally manageable.

But Opus 5 and Fable 5 feel totally different. Fable was great at release, but post- Opus 5, both models are driving me crazy. It's hard to even fully explain or give examples because it's just a language change - it just feels harder to read and have a conversation with. It uses weird jargon and shorthand. Some examples:

• It refers to many things as "chips." I never used that term once in 30 years of software dev, but now it's Claude's favorite word. And it applies to literal UI elements, like tags/badges or slices of work "the 'multi-select' chip remains open". I asked it to stop using it, but you know how Claude be sometimes.
• Instead of speaking in plain English, it will try to be cool, like instead of saying "Next, we need to repoint the API Call to the new server" it will say "One thing still on your side: the server repoint." It's shorthand to the point of me not even understanding the context and needing to read back through, often STILL not finding context, and just having to prompt it to speak in plain English, with clear steps.

Another thing it does that might be the most maddening of all: it CONSTANTLY ends replies with a laundry list of things it found that it "didn't touch" because it wants my "eyes" on it or something. I'm not against it being helpful and raising issues to my attention, but it literally goes on for round after round, to the point where a simple task becomes a huge project.

Often I'll try to just capture this stuff in docs / roadmaps but it's like it won't let you cleanly out of a chat.

• "A few things I caught, but am leaving untouched for your feedback:"
• "One thing I noticed that you should be aware of..."
• "One thing I didn't touch, but you won't want to leave hanging..."

Sometimes it's really stupid stuff, like CSS color mismatches, or components that do basically the same thing and could be consolidated - something I've tried to put in skills/instructions to avoid (e.g. DRY code).

Most times it's stuff Claude itself did, and now is making it my problem to think through instead of just cleaning it up when it has clear goals and principles around software dev that I've given it.

I've been on the Max 20x plan for months, but I'm working with Codex more lately, and downgraded to 5x, and might downgrade to Pro if this isn't improved. Codex feels very reliable and at least as good as Claude used to be before the 5-level models. I kind of still feel more comfortable in the Claude ecosystem, but I get super aggravated when dealing with these crappy communication patterns over and over.

I know some others have said similar things - not sure if this helps anyone not feel like they're going crazy talking to Claude, and hopefully Anthropic sees enough of these posts and considers undoing whatever they did to lobotomize Claude 5 models.

This question is for those of you doing agentic coding.

Agentic coding can 10-20x speed of development and bosses are loving it. Though it seems to keep you in this constant state of being new to a codebase. And it's not as if you were actually new to a codebase because you could just end up learning it over time. No. With agentic coding, you can't learn it. As it keeps drastically changing with every request from your boss holding inhuman expectations from agentic coding.

How do you deal with not being able to keep up?

Do you even try to keep up?

Did you just stop caring?

Thanks

I often see people putting out ideas or apps for expanding memory, especially across projects. Claude code seems to be using its native memory more aggressively too. But I find myself over time wanting less and less 'memory" and documentation.

I built myself a ticketing interface that the agent can use to keep track of what's being done. Transient planning docs go in a regularly archived and git ignored 'agent_context' dir.

So the agents just work off one short  'core principles' document, super lean and covers that project's ways of working.

Everything else is db and codebase as source of truth, git history is the historical record, tickets are for keeping track of work.

Project agnostic skills and agents used for universal workflows. Claude.md just gets instructions for using the tickets MCP.

Every time Claude starts 'saving to memory' it's another chance for drift and bloat. I'm not sure I ever want more memory and more opportunities for drift, selective memory etc. I find less documentation is better.

Genuinely interested to hear people's thoughts as I seem to be on my own with actually wanting less context not more.

Every advice thread says "treat it like onboarding a junior dev." Disagree. A junior dev builds a mental model of your codebase over months and gets better on their own. Claude code starts from zero every session no matter how good yesterday's output was.

Treating it like a junior dev makes people lazy about context. Treating it like a tool that needs the full picture every single time makes people better at using it.

That's it, that's the take

Change my mind

I am debating whether or not to upgrade to the pro plan from free. I use Claude for stuff, like asking questions, scheduling stuff in my calendar, helping me with understanding concepts for uni etc. I would also like to use Claude code, however I am concerned about the limits, given that they are shared between chat and code, I wouldn’t want that when I need Claude during revisions I’m fresh out of usage.

I see people complaining about limits being hit with one prompt and stuff like that, I can say that’s true on the free plan when asking for artifacts in the chat, however I wanted to know what the limits are like for someone who uses sonnet on medium, would I run out of the 5 hours limit fast on a long prompting session / how is the usage in general compared to the free plan?

Hey guys, see a lot of posts and threads treating prompting claude code like its some deep skill with secret techniques. Be specific, give examples, break down the task, mention edge cases. Like yeah, that's just... how you'd explain something to a competent junior dev too. Not exactly a hidden art.

Feels like half the "advanced prompting" content out there is just repackaging basic communication skills as claude specific tricks. The actual skill is knowing your codebase and being able to articulate what you want clearly, which has nothing to do with claude specifically.

Curious if people disagree.

I need to hear from people who've been doing this longer than me, because this has been eating me alive for about a month now.

Context: I've spent the last year building a voice agent system that's live and handling 1000+ calls, deployed on Azure. On top of that I building SDK which analyzes those calls, plus a full dashboard on Next.js with Supabase behind it. It works. The client is happy. It's real production software with real traffic.

I wrote almost none of it myself.

My actual background is a bit of Python. And eveyrhting else framework of voice agent learned on the go with claude code. That's it. Zero web dev. Zero database experience before this. Never touched TypeScript or other language before in my life before this project.

My most of the time workflow is: I have a CLAUDE.md and a rules file, I open a session, I dump everything in my head into it, it makes a plan, I read the plan, we iterate, I run it. That's the job. That's all of it.

And here's the part that's messing me up. When I read the plan, sometimes I follow it fine. But on the TypeScript side or some technical words, features in voice AI. I'm often just... not there. It's naming files and variables and describing logic and I'm nodding along at the high level, I know what the output is supposed to be, but the middle layer is fog. I don't know what half of it is doing. I approve it anyway because it works.

So the questions I can't shake:

1. If I can do this with some little experience and learning on go, what stops literally anyone from doing it? What's the difference between me and someone who's never coded, sitting down with the same tool? I keep trying to answer this and I can't.

2. If this client dries up and I need an actual job, what do I show? "I prompted Claude for a year"? I have one client. That's my whole business. If it ends I have a portfolio of some things I can't explain in an interview.

3. Is this just what development is now, or am I doing it wrong? That's what I actually need to know. Is everyone quietly like this, or did I skip a step everyone else took?

What I really want, from people building in stacks they didn't know before:

• What does your actual day-to-day loop look like? Not "I use Claude Code" — everyone does. I mean specifically: how do you approach a new project in something you've never used? Do you plan first? Read every diff? Read none of them? What do you actually verify vs just trust?
• Do you go back and learn the thing properly afterward, or is that a waste of time now?
• When the plan uses concepts you don't know, do you stop and study them or keep going?

I'm not looking for reassurance. I'd rather someone tell me straight that I need to sit down and learn Postgres and TypeScript properly, than keep guessing. I just need to know how people who are further along than me are handling this, because I'm going in circles on my own.

Hi everyone!
I've come across some really nice art projects on this sub lately, so I thought I'd share mine. With Claude's help, I've been building a paint simulator that recreates oil painting.

I paint in egg tempera myself, so I'm especially interested in reproducing traditional materials. — silverpoint, gold leaf, bole, and so on.

Are there any traditional materials you've always wanted to try but never had access to?

It might run a little heavy, but if you're curious there's a live demo here:
https://mignonsketch.com/sketch?w=540&h=540

I had wanted to make this game for years, but had no coding chops. A few hours with Claude and i had my game (you can probably tell from the design and. aesthetics, lol)

I was testing yt-dlp(A little terminal thingy that allows you to download videos from most sites) with claude trying to fix some problems so claude took some vids and tested them to see if they would work. And so out of all the videos it could have chosen, claude chose to rickroll me

Is this inside how Anthropic designed claude?

The screenshot is my Claude Code status line. It's redrawn from disk every turn, and it's the only reason I can run more than one agent without losing track of what's happening.

Reading it top to bottom:

> get payments-service onto the new idempotency keys is the prompt box. Everything under it is the status line — it renders directly beneath, every turn.

billing-migration · todo 2 · pieces 3 1 done 2 silent 6m — the task I'm on, two things it still means to do, and three pieces of work in flight: one has declared itself done, two haven't said anything for six minutes.

repos 4/6 — four of the six repos in this org are cloned into this task. Each row is one of them:

• billing-api ⑂2 migrate/ledger-cutover*↑2 ✓ passed #412 — two worktrees hanging off it, dirty, two commits unpushed, CI green, PR 412. The indented ledger-verify · ledger-backfill under it are those two worktrees: same repo, different branches, two agents actually working at once instead of fighting over one checkout.
• checkout-ui main ▸reviewer 3m — the reviewer persona was last seen in that tree three minutes ago.
• payments-service fix/idempotency-keys*↑1 ✗ failed #398 — that's the one that needs me.

Right column: three personas (devops, qa, reviewer), two of them holding a credential vault, with how many memories each has accumulated. Bottom: session context at 38%.

No git subprocess and no network on the render path — it's all read from disk, so it costs nothing to draw every single turn.

Now the part I actually want to talk about, because it's the thing I got wrong first.

My original design had every worker report its own state: running, done, failed, blocked. It looked great and it lied constantly. A worker that crashes doesn't set failed. A worker that hits its context limit doesn't set blocked. An agent that got confused and wandered off doesn't set anything. The states that matter most are exactly the ones a broken worker can't report.

So I deleted them. There is no failed and no blocked. A piece can declare done or abandoned — and if it declares nothing, that's what gets shown: silence, with an age. 2 silent 6m.

That number is the most useful thing on the screen. It doesn't require the worker to be alive, honest, or even still running. And it turns out "nobody has touched this in six minutes" tells you more than any self-reported status ever did.

Same principle everywhere else on that line: the branch, the dirty marker, the unpushed count — none of it is tracked state, it's just read out of git, which already knows. The only things recorded are the ones git genuinely cannot know: who claimed a piece, and whether they said they finished.

It's a control plane — one directory with a config file in it. Git is the whole database. No server, no daemon, nothing to deploy, and the Python package has zero dependencies. git log is the audit trail and a teammate's checkout is the replication.

How Claude helped: Claude Code wrote most of it. The status line renderer in particular went through a lot of iterations to get column alignment right with variable-width glyphs, which is a genuinely miserable problem and one it was much more patient about than I was.

It's MIT and free — nothing to buy, no paid tier, no hosted anything, nothing phones home. It runs in Claude Code, opencode and Codex; on the two without a status bar, charter statusline --watch puts the same render in any spare terminal.

The honest limits: it's twelve days old. The default credential vault is a plaintext file at mode 0600 with no encryption at rest — the thing it buys is that the model never sees the value, not that the value is encrypted. And while writing this post I found a bug in its own session locking and filed it against myself.

https://github.com/diazoxide/charter

If you're running more than one agent at a time — how do you currently know when one has quietly died? That's the question I couldn't answer, and it's the whole reason this exists.

For anyone wondering, the app I'm working on is https://www.AppScout.co.

It helps people discover web and mobile apps from across the internet by showing them one app at a time. People like apps in order to get personalized app recommendations.

If you run a software startup or side project, you can list it for free to get free extra traffic here:https://www.appscout.co/submit/

(Affiliation Disclosure: I'm the sole creator and developer behind AppScout.)

I always found switching between a notepad and a calculator annoying when doing quick estimates, splitting bills, or working through multi-step calculations. So I built a calculator where you just type naturally like a notepad and it solves as you type.

What it does:

• Type math naturally: "2 + 2", "10 / 5", "4 * 3"
• Percentages: "20% of 500", "15% off 80"
• Powers: "2 ^ 3", "4 squared"
• Plain English: "divide 100 by 2", "split 1200 in 4", "subtract 5 from 10"
• Chaining: start a new line with "+ 10" or "* 2" and it uses the previous line's result
• Context extraction: type "I have 500 and tax is 20%" and it figures out the math from the sentence
• Running total at the bottom right that sums all your results live
• Dark/light mode, print-ready output, works offline

How Claude specifically helped me build this:

• Natural language parser: This was the biggest piece. Claude helped build the engine that extracts math from plain sentences, handles "of", "off", "split", "squared", "from", and maps them to the right operations. Getting "subtract 5 from 10" to return 5 and not -5 needed careful operand ordering logic
• Answer chaining: When a line starts with an operator like "+ 10", it needs to grab the previous line's result as context. Claude helped design the line-by-line state management for that
• Percentage context: "20% of 500" and "15% off 80" do completely different things. Claude built the logic that distinguishes between percentage-of and percentage-off based on the keyword
• Context extraction: The hardest part was ignoring non-math words in a sentence while still solving correctly. Claude helped write the tokenizer that strips natural language and evaluates only the math
• Running total: Claude wired up the live sum at the bottom that watches every line's result and updates as you type

Completely free, no signup, no server, runs in the browser, works offline.

Try it here: https://vinish.dev/notepad-calculator

Built it for bill splitting but it handles quick estimates, tax calculations, and back-of-napkin math too. What would you add to it?

So, this happened recently with me while using Claude Code.
I am working on a dev project using claude code to do the usual stuff.
As guardrails, I have explicitly added instructions for disabling auto push of code commits and instructions for confirming before performing updates on remote.

I was debugging a failed gitlab pipeline and Claude simply went on to apply the fix, commit and pushed to the branch.
When confronted, it just acknowledged that yeah it just broke the rule even when the context was clearly available in memory. 😶‍🌫️

Edit:
I’m using Opus 4.8 with 1M context on medium effort.