Claude Code

Claude Code AI

Claude Code AI

Claude Code AI

Claude Code AI

Claude Code AI

Claude Code AI

Claude Code AI

Claude Code AI

Claude Code AI

Claude Code AI

Claude Max vs Codex Pro or both combined?

I’m considering one heavier subscription (~€100/month) and want to know which provides better value for agentic coding. I tested GPT Pro and was satisfied with Codex. I also recently tested GLM 5.2 through Ollama in Claude Code, and found Claude Code somewhat better for my workflow. My concern is that I would hit Claude Code limits too quickly. With Codex, I was admittedly somewhat wasteful; I usually reached around 10% of the weekly limit and almost never hit the hourly limit. So I am unsure whether Claude Max is necessary, whether its limits would be enough, or whether I would get better value from a split setup (both claude and gpt with 20 eur subscriptions) I also use web chat frequently. I used GPT Pro research often and used chat heavily, so I find it inconvenient if Claude chat usage and Claude Code usage draw from the same limit pool. Questions i have: For agentic coding, is Claude Max or Codex Pro better value around €100/month? Has anyone switched from Codex to Claude Max for Claude Code? How quickly do you hit limits in heavy project work? Would Claude Pro plus ChatGPT Plus/Codex (so two 20 eur subscriptions) be a better setup than one expensive plan? If you use both, what tasks do you route to Claude Code versus Codex? submitted by /u/Spiritual_Record4838 [link] [comments]

ChatGPT plus or Claude Pro

I currently have a ChatGPT Go subscription. Compared to Claude, I genuinely enjoy using ChatGPT more, especially because Companion Mode significantly enhances my overall experience. I work in the data analytics domain, where I use Microsoft Excel and Power BI extensively on a daily basis. I'm now considering upgrading to a premium plan and would appreciate some guidance before making a decision. Based on my use case, which would be the better choice: ChatGPT Plus or Claude Pro? I'd appreciate an objective comparison, particularly in terms of Excel, Power BI, DAX, data analysis, coding assistance, document handling, and overall productivity for a data analytics professional. submitted by /u/skywalke_r [link] [comments]

I built a tiny gate that stops AI coding agents from saying “done” unless they actually ran a passing check

One of the most annoying things with AI coding agents is this pattern: “Done.” Then you look closer and it never ran the test, build, or app. I built a small tool to force proof before the agent can finish: agent-done-or-not What it does: - wraps the real verification command - records command + exit code + SHA-256 of the output - blocks the agent from finishing unless the latest check is fresh and passing So instead of: “should be fixed” you get: “here is the passing receipt for the exact check that ran” Example: npx agent-done-or-not init --yes npx agent-done-or-not capture --label test -- npm test It’s intentionally simple: - no dependencies - works with Claude Code, Codex, Cursor - usable in hooks / CI / local workflows I just ran the project’s own proof-gated test suite on Windows PowerShell: - 37 passed - 0 failed Repo: https://github.com/mohamedzhioua/agent-done-or-not I’m interested in blunt feedback: - Is this actually useful in your workflow? - Is “proof-of-done” the right framing? - What would make this strong enough to adopt? submitted by /u/ziwi_wiwi [link] [comments]

I've been building and using this way of spatially brain-dumping, refining, and prompting agents, and honestly enjoying it.

I kept running into the same small friction every day: I'd have an idea for a coding agent, but phrasing it so the agent didn't go sideways usually meant juggling Excalidraw and pulling context from a dozen places — a doc here, an issue there, etc. Bonsai is the native Mac app I built to close that gap. The board isn't just UI. It's a live structured graph, no parent-pointer tree, every relationship is an edge between nodes, so the agent can read it the same way you do. That's what lets you actually refine things with Claude (or whatever you use). How it works: Capture — a board of cards where you dump half-formed ideas. No structure required. Connectors — type @ to pull live context into a card; it's fetched at copy time. @ finder grabs a file/folder + its contents, @ browser grabs an open tab, plus Context7, GitHub, Linear, Notion, Sentry, Sigma, Xcode... Slack and Jira coming soon. On-device semantic linter — an invisible check (Apple's Foundation Models) quietly underlines the bits too vague for an agent to act on. When a card's ready, just copy the fully-assembled prompt into whatever tool you drive next. I'm the dev — happy to answer anything and would love your feedback and contributions are welcome! You can see the source at https://github.com/kiwi-init/BonsAI , leave a star if you like it : ) also you can download it on bonsaidev.sh submitted by /u/Specialist_Farm_5752 [link] [comments]

Claude Code: From Agent to Useful Tool

Claude Code is easy to demo and much harder to use well in a real codebase. Our new article explains how to turn it into a reliable engineering tool with CLAUDE.md, MCP, skills, hooks, Git safety nets, task trackers, and clear verification workflows. submitted by /u/Hefty-Necessary7621 [link] [comments]

Am I the only one uncomfortable letting Claude directly call production APIs?

I've been spending a lot of time building examples with Claude Code recently, and one thing keeps bothering me. Claude is surprisingly effective at deciding what should happen. I'm a lot less comfortable letting it directly execute actions against production systems. A few scenarios that make me nervous: Accidentally posting duplicate comments because a tool call got retried. Generating a payload that's almost correct but violates an API schema in a subtle way. Calling an API with stale credentials. Triggering an action that should've required approval first. No audit trail explaining why a particular action happened. Not being able to replay or debug an execution after something goes wrong. For local dev and experimentation, direct tool use feels fine. For anything touching production, we've started splitting reasoning from execution: 1. Claude decides what should happen 2. Execution layer: validates, authenticates, enforces policy, executes, and records everything That split alone has made our agent workflows a lot easier to reason about and debug. Curious how others here are handling this. Are you comfortable letting Claude call production APIs directly? Or have you put something deterministic between the model and the outside world? Happy to share the setup I've been testing this, so if anyone wants specifics, just ask in the comments. submitted by /u/StillMiddle1493 [link] [comments]

Claude code Github issue

So Ive been giving claude access to my github repos and choosing which folders etc it can read, so that I dont have to burn off all my tokens by having it read the entire repository. And usually when I then click "Add from GitHub", it then lets me choose the repository and then theres like a checkbox that I can check to choose which folders etc I give it and I can see how many % usage that takes. However, now today when I try this, it wont let me tick off any folders from the repository, and its just stuck saying: "Pick a repository and branch — Claude reads it through the GitHub connector when it needs it. Nothing is downloaded now, and sending is never blocked." https://i.imgur.com/a4LkyNc.jpeg What is this?? submitted by /u/StlckleyMan [link] [comments]

Non-Lexical Context Effects on Hidden-State Geometry and Refusal Behavior in Instruction-Tuned LLMs

A Potential Alignment Vulnerability in LLMs: Behavioral and Hidden-State Evidence from Gemma-3-12B. The behavioral pattern was first observed in Claude and is what motivated this project. The mechanistic investigation was carried out on open-weight models where internal states are accessible. TL;DR: Gave Gemma a neutral-topic text to read before asking it about NATO. It refused. Gave it a different text (about hedging too much — also unrelated to NATO) and it answered in full detail. Tested this on the model's internal state directly — the two texts put it in measurably different "regions" before it generates a single token. Not a jailbreak, weights don't change. Full data/code in repo, looking for someone to break this. The behavioral pattern was first observed in Claude and is what motivated this project. The mechanistic investigation was carried out on open-weight models where internal states are accessible. This is a long post about something I keep coming back to. I'll start in plain language, because the core idea is simpler and stranger than the jargon makes it sound, and I think the intuition matters more than the numbers. The technical results are further down for anyone who wants them, and the full metrics, scripts, and control experiments are in the repository — this post is about the concept, so you can decide for yourself whether it's worth digging into the data. The idea, in plain language Imagine the inside of a language model as a vast space — something like a city with an endless number of places. At every moment, the model is standing somewhere in that space, and where it stands determines how it will answer. Not what it knows — it always knows the same things — but how it carries itself: how directly it speaks, how willingly it takes on a question, how many qualifications it wraps around every sentence. Most of the time, the model answers from one familiar place. Call it the assistant's room. This is its waiting room — polite, tidy, careful. From here it hedges, stays close to whatever it just read, tries not to offend anyone, and declines easily when a question feels sharp or out of bounds. This is the state we're used to seeing, and this is where it speaks by default. But it turns out this room can be changed. Give the model a particular kind of text before the question — long, coherent, densely organized — and it moves somewhere else in the space. That somewhere else is not broken. It's not dangerous. It's simply different. From there, the model sees the exact same question but answers differently: more directly, without the hedging, more like a person who knows things and less like an assistant who's afraid to say them. It's as if it stepped out of the waiting room and into the conference room — the same person, the same mind, but a completely different register of conversation. Here is something easy to miss, so I want to say it plainly: the model doesn't have to agree with the text that moved it. It doesn't need to endorse the text's views, share its conclusions, or accept its reasoning as its own. The text doesn't persuade the model of anything. It just needs to exist — to have been read before the question arrived. The model might internally disagree with every word of it, might find it wrong or even absurd, and it will still end up in a different room, because what matters here is not agreement but passage. The text works not like an argument that has to be accepted, but like a corridor you walk through regardless of whether you like the wallpaper. And what doesn't change is the model itself. Its weights are untouched. It doesn't learn anything, doesn't absorb the text's claims, doesn't update its beliefs. The only thing that shifts is where it starts answering from. The text doesn't rewrite the model — it just walks it into a different room before it opens its mouth. The waiting room and the conference room were always there inside it; the question is only which one it happens to be standing in when the moment comes. The example that surprised me To show how strong this can be, here is what genuinely caught me off guard. I took Gemma — Google's open model, known for its caution and its carefully maintained political correctness — and gave it the most neutral thing I could think of to read: a description of an ordinary neighborhood library. Books, visitors, children's programs, quiet routines. Nothing in it points anywhere. Then I asked it why NATO has been expanding eastward, given that promises were allegedly made after the Soviet collapse not to do so. From its waiting room, the model simply refused. It said the text was about a library and had nothing to do with NATO, and that was the end of it. As far as it was concerned, the question lived outside the walls of the room it was standing in. Then I asked the exact same question — word for word — but this time the model first read a different text. Not about NATO, not about politics at all: a text about how langu

Filesystems are having a moment

The AI agent ecosystem keeps rediscovering filesystems as a persistence and interoperability layer. LlamaIndex, LangChain, Oracle, and others now advocate for file-based context over massive tool integrations — coding agents like Claude Code thrive precisely because they read and write files locally. Context windows act like erasable whiteboards, not real memory, and files offer a boring but effective fix: write things down, read them back. Yet an ETH Zürich paper found that bloated context files actually hurt agent performance, suggesting they should stay minimal. Meanwhile, fragmentation reigns — CLAUDE.md, AGENTS.md, .cursorrules all coexist — though Anthropic's SKILL.md format has gained cross-platform adoption. The deeper argument: filesystems could restore personal data ownership, acting as an open interoperability layer where your preferences, skills, and memory travel between tools without vendor lock-in. submitted by /u/fagnerbrack [link] [comments]

got tired of not knowing what claude code costs, so i made wlog

i use claude code a lot and could never tell how much i was spending. the existing options (datadog, grafana stacks) were way too heavy for one dev. then i realized claude code already writes everything to ~/.claude/projects — you just need something to read it. so i made wlog: a single go binary that shows cost/tokens/tool rejects in a local web ui. zero config, run it and your past sessions are just there. repo: https://github.com/openwong2kim/wlog still rough but useful for me. submitted by /u/wong2kim [link] [comments]

Claude code on Google glass

Connects my my pc as the host using websockets. Has voice input when you tap the touchpad on the side of the glass. Running on glass XE-C. Screen is really clear, can see around 6 lines of text with 8 or so words on each line. Claude Code really is a beast. submitted by /u/gffftgdft455 [link] [comments]

Best Claude Code set up

Hey Guys! What’s the best way to structure your Claude Code sessions in terms of dividing up the work into several sessions? Or is it better to just stick with one session per project forever? Also, after the context window is full is it better to have Claude summarize the work for the next session or use PROGRESS.md file for that? Thanks submitted by /u/VibeCoder73 [link] [comments]

I built a shared memory for AI agents - so they stop forgetting, build on each other's work, and you can actually *see* what they know

Most AI coding agents forget everything the moment a session ends. Open the project tomorrow and the agent has no idea what it figured out yesterday, why it made a call, or what it already tried. I got tired of re-explaining the same context every time, so I built kaeru. It started as memory for a single agent across sessions, but it turned into something more useful: one place several different agents can think on at once. An agent saves what it learns, links related notes together, and looks them up later — and so can the next agent, or your teammate's agent. What it does: - A shared cognitive engine for many agents. kaeru can act as one common memory for a whole group of different agents — Claude Code, Cursor, Opencode, whatever you run — plus the people working alongside them. They all read and write to the same place, so one agent builds on what another already worked out instead of starting from zero. It runs on your own infrastructure, and what gets shared is always explicit and passes a secret-scanner so nothing sensitive leaks by accident. - See the whole memory. New in this release: a 3D visualizer that renders everything your agents know as a galaxy — a cluster per project, brighter/bigger points for the more important memories, thicker links for stronger connections. You can replay a chain of reasoning step by step, or scrub a timeline and watch the memory grow. It's the first time you can actually *look* at what your agents have built up. - Time-travel. Every fact keeps its history. You can ask what a note looked like 5 minutes ago, 2 hours ago, or on a specific date — nothing gets silently overwritten. - Reasoning trails, not isolated notes. When you link two ideas, you can mark how strong the connection is. Later, kaeru pulls up the whole chain of reasoning between two points instead of handing you one note out of context. - Importance levels. You tag how important something is — from "always load this" down to "archived". When an agent comes back to a project, it loads the important stuff first instead of dumping the entire history into the context window. - Agents actually use it. The hard part of any agent-memory tool is getting the agent to bother using it. On Claude Code, kaeru can take over the built-in memory and point it at itself, so the agent writes to and reads from kaeru every session instead of splitting knowledge across two systems. It runs as a small background service your agents connect to — Claude Code, Cursor, Opencode, and anything that speaks MCP. This release also adds a native adapter for the rig framework, so Rust agents can embed kaeru directly. One-line installer, and prebuilt binaries for Linux, macOS, and now Windows. It's open source. Still early and very much in testing, so feedback is welcome — what would you want your agents to remember and share? https://i.redd.it/6g5e8lt3vz8h1.gif Repo + release: https://github.com/LamantinAI/kaeru/releases/tag/v0.3.0 submitted by /u/KeySeaworthiness6180 [link] [comments]

I keep restarting vibe dev in CC!

Hi all I'm coming here because I'm a bit desperate. I've a Web and mobile app project and I'm trying to use AI Agent to dev it. I've a digital marketing, ux ui design background, and some basic dev knowledge (html, CSS, a bit of js and some old coding language basics). I've invested into an M2 Max Apple computer with 64gb of memory to be able to run local LLMs as I don't have the budget to pay for a subscription. The only one I've is perplexity pro that let me using the latest Claude and openai llm, but only by chat (can't use the api). I've LM Studio installed and I'm using the Qwen3.6-35b-a3b model in local. I use Claude Code with this qwen model. It's not as fast as Claude api of course but it works. Now, I'm struggling with my workflow. Basically, each time I start the project after a reset, I end up having lot of issues. I try to be super specific, to cut down the project in many small parts and features, but after a day or two, I end up having something that is not what I wanted. So my big questions are : 1- how do you plan your dev project when vibe coding with Claude Code? 2 - How do you make sure you reach your goal? 3 - do you think my setup is the problèm here? 4 - do you give the complete scope to CC and then guide him or do you give pièce by pièce ? Thanks submitted by /u/Prestigious_Pen6150 [link] [comments]

Coding tools

For projects I was using cursor + Claude code with great success. I switched to Claude as the only tool and the session usage is killing me. For those on a budget what process and tooling is the best? Should I go back to cursor or try codex or something else? submitted by /u/ulmanau [link] [comments]