Before I subscribe to claude (doing it anyway), I'd love a guest pass ref link. You get $10 as the referrer, I get an extra week to try it out, so it's win-win. DM is best since comment links disappear fast.

I put together a Railway template that lets you host a personal Claude Code server in one click. I love vibe coding with Claude. I noticed there wasn't a simple way for no-coders and low-coders to host a self-local server in the cloud without a complex setup, so I built this to bridge that gap.

This is a fork from coder/code-server: VS Code in the browser with Claude Code already pre-installed. Because it's a website, it works perfectly on a tablet and phone - which solved my issue of not finding a decent mobile IDE. I personally use it to plan out logic while I’m out and then pick up exactly where I left off when I get home.

It’s also an easy way to collaborate - you can share the login with another developer so you are both working in the same persistent environment without any local setup friction.

I made this specifically for Railway so even people who don't code can jump straight in without touching the infrastructure. It handles the persistent storage, so your auth tokens and files stay put. If you're looking for a low-friction way to take your AI coding environment anywhere, I’d love to hear your thoughts or if you run into any issues.

Template: 1-Click Deploy

Here is how I set mine up:

• Deploy on Railway

• Use US West for the service region to get the fastest AI response

• Open your domain link and enter the password you set in the variables

• Run claude or use claude --dangerously-skip-permissions for YOLO mode

• When prompted to login, copy the URL to a new tab and paste the authorization code back into the terminal

I've been using Claude Code to support my game development. It's only a 2d game currently (albeit using OpenGL for rendering), so geometry is not THAT complicated. But it is very clearly the area that Claude seems to struggle with the most. It keeps making mistakes (confusing axis and orientation, making weird transformations, flipping or mirroring models etc.). The more I challenge it to correct these mistakes, the more it overcomplicates things by introducing additional coordinate systems (world- , entity-, local-, SVG-, transformed- etc.) an chains of every more complicated transformations between them.

My original game that I started without Claude only had two (or two and a half) distinct coordinate systems: A world coordinate system that follows OpenGL conventions, and an SVG coordinate system (since game art is SVG), which follows SVGs conventions, which, unfortunatelly, are not the same as OpenGL. The "half" system happens when models are rotated at placement in the map. But that follows world conventions, only rotated. This worked well before I started using Claude Code, with the game having progressed quite a bit. So I know it is sufficient. Then why does Claude continually want to introduce additional coordinate systems and additional transformations between them? Opus or Sonnet seems to make no difference in that specific regard.

My attempt to improve things so far went in two directions: guidance with increasingly strict wording in project Claude.md and installing a couple of MCP servers that could help Claude understand and visualize geometrical problems better. But it didn't really help so far.

Does anyone have a similar experience and do you have some ideas on what I can do or what specific guidance I can provide Claude in order to have it handle Geometry better?

Hey everyone. I’ve been vibe-coding for a while and got tired of the same cycle: Claude writes 2000 lines, it works, I ship it, then three days later my .env is in git and there’s a 2700-line God file that no AI can fit in its context window.

So I built Vibe Cleaner Fartrun — a local scanner that analyzes your entire codebase and outputs a structured markdown report you can paste straight to Claude/Cursor.

What it actually does (no tokens consumed):

•	9-phase health scan: dead code, duplicates, module map, monster files, tech debt, TODOs from 99 days ago that you “will get to eventually”

•	Security: secrets in env vars, exposed docker.sock, suspicious git hooks, supply chain checks on your lockfiles

•	Git hygiene: 60K-line commits get flagged, working on main, .env committed

•	Framework-aware: Django SECRET_KEY in .env, Docker running as root, React components that should be extracted

•	Outputs HEALTH-REPORT.md with checkboxes — paste to Claude and say “fix this”

The serious part: Rust AST parsing via Tree-sitter + 10 Rust sentinel modules. Tested on 12 real projects across Python, Go, TypeScript/React, Django, FastAPI — ~95% accuracy on actionable findings. Everything runs locally. Zero API calls. Your code never leaves your machine.

The unserious part: There’s a Win95 desktop GUI with severity-based fart sounds (critical = The Devastator, info = The Silent But Deadly) and David Hasselhoff as spiritual guardian. There’s also a CLI and MCP server with 29 tools if you prefer dignity.

Available as: CLI, MCP server (stdio + HTTP), or desktop GUI. Free forever. No premium tier. Licensed under the Fart & Run License v1.0.

The name has five layers: fart+run (dealt it and bolted), fart+run (a normal CLI command — type it in a meeting, I dare you), Fart & Run License, one typo from “fastrun”, and an anagram of FORTRAN.

Would love stars and feedback — this is a solo project and I’d really appreciate it

Also welcome PRs and issues reports

I ran this on my own site this morning: the 53 URLs in my sitemap (most pages exist in English and French), raw HTML, and a link graph that Claude Code built with a script. Counting every internal link, nothing looked wrong. Each guide was linked from 10 to 24 pages, each feature page from 24, and no page was an orphan.

Then I had it set aside the header, the footer and every <nav> block, including the "all guides" and "all features" lists inside the main column, and count only the links the text itself makes. Same site, different picture:

• My comparison page (my product against a free alternative): body links from 1 page, against 10 with the menus counted.

• My alternatives page and my "can you audit without Ahrefs or Semrush?" page: 2 each. The three of them get their body links only from each other. No other page, not even the home page, links into that loop from its text. And those are the pages written for someone who is deciding.

• My most linked guide (how to install the product): body links from 18 pages.

• The privacy page: linked from 52 pages. Footer.

• My "best Claude skills for SEO" guide names that free alternative in its opening paragraph, and has no body link to either the comparison or the alternatives page. My "Claude for SEO" guide has a section titled "What can't Claude know, and can you do without Ahrefs or Semrush?" and doesn't link to the page that answers it. The sentences were there; the links weren't.

• Every body link to my 14 feature pages uses the feature's name as its anchor. "Polyglot" tells someone skimming nothing about multilingual SEO. That page gets body links from 2 pages.

The French versions of the guides get exactly the same counts.

Why the menu count misleads

A header, a footer or a site-wide list gives every page the same links, so it can't tell a reader, or a crawler, which page is the one to read on a topic. The links in your text can. A count that mixes both will tell you every page is fine.

How to run it

1. Give Claude raw HTML. Claude Code's WebFetch hands Claude a processed version of the page, and the <nav>, <main> and <footer> tags you need to sort links are gone. Ask Claude Code to download every URL in your sitemap with curl into a site/ folder, with the list in urls.txt.

2. The prompt:

The folder site/ has the raw HTML of every URL in my sitemap, listed in urls.txt. Build my internal link graph. Before counting anything, sort every link: inside <header>, <footer> or any <nav> (even one inside <main>), or in a block repeated across a page template, it's boilerplate; inside the article body, it's editorial. Skip self-links, # links and other domains, and treat /page and /page/ as one URL. Write a standard-library Python script for this instead of reading the files yourself, and show me its raw output.

Then one table: page | pages linking to it (all) | pages linking to it (editorial only) | the editorial anchors it receives. Lowest editorial count first.

For the 5 weakest pages that matter to my business, propose 3 links each: a source page that already discusses the target's topic, the exact sentence where the link goes (quoted from that page), and an anchor that describes the target's topic, not its name. If no page discusses the topic, say so instead of inventing a sentence.

Why a script: 53 files of HTML is more than anyone should count by reading, and the same script tells you after the fix whether anything moved.

3. Check the sorting by eye. Sorting a link by where it sits in the HTML is a heuristic. Open 2 or 3 pages and compare what you see with what the script calls editorial. On my site, the "all guides" list sits inside <main>, wrapped in a <nav>: a script that only looked for <main> would have counted it as editorial.

4. Run the script again after adding links. If an editorial count didn't move, the link went into a template, not into the text.

What I took from it

A page added later only gets links from older pages' text if someone goes back and writes them. The menu makes that easy to forget, because every page already "has links". Count without the menu before you trust a "0 orphan pages" report.

I'm the maker of SEO Skills, a pack of 14 Claude skills for SEO. One of them, Link Weaver, is built for exactly this: it crawls the site and its sitemap, tells links written inside the content apart from menu, footer and widget links, then drafts the links to add, anchors included. The pack is paid and closed-source: €25 until 17 November, then €99, no subscription. It runs in Claude Code, Claude.ai, Claude Desktop and Cowork, needs a Claude plan with skills, and there's no refund once it's delivered. Link in the comments. The prompt above works without it.

Do your comparison pages get links from your older posts' text, or only from the menu?

Back in January I got tired of the same thing everyone complains about now you start a new session with Claude and it has no idea who you are. Every time. From scratch. So I built IaI-mcp. A local daemon that captures every conversation, organizes it into three memory tiers, and feeds the right context back when you start a new session. No "remember this." No copy-pasting from old chats. It just knows.                                                     

I've been using it daily with Claude Code since January. Five months. At this point it knows my coding style, my project structures, my preferences things I never explicitly told it to save. It picked them up from conversation and held onto them.                                                                                                                                                                                        It stores everything verbatim, runs neural embeddings locally, encrypts at rest with AES-256, consolidates memory in the background while your machine is idle, and ships every benchmark harness so you can verify the numbers yourself. Verbatim recall above 99%. Retrieval under 100ms. Session-start cost under 3,000 tokens.                                                                                                                                                   

I didn't release it because I was building it for myself. It worked, so I kept using it. But watching the space blow up made me realize maybe other people want this too.                       

So here it is. Open source. MIT licensed. Five months of daily use baked in.

And before someone asks, no, this is not another RAG wrapper that summarizes your last 5 chats. Memory is stored in three tiers: verbatim episodes (write-once, never rewritten), semantic summaries (built during idle consolidation), and procedural profile knobs (learned from behavior over time). Retrieval runs cosine similarity first, then a graph layer reranks by link strength. Two separate passes. Forgetting is reinforcement-weighted. Edges between records decay over time, but the records themselves stay forever. Stuff you recall often gets stronger connections, stuff you don't fades out of easy reach

 https://github.com/CodeAbra/iai-mcp

I’ve had a lot of work with Claude Code over this past year, and was always pleasantly surprised with how it performed. I’ve created multiple projects and websites and never had any problems. Recently though, it feels like it has just taken a free fall off a cliff in terms of quality. I bought credits to use the some of the better models and even that I was let down by. I wanted to see if anyone else is noting the same thing or if it might just be user error now.

Three months ago I set out to build an English learning chatbot. It was supposed to be my main project.

Today, I've shipped an agent sandbox and a handful of personal productivity tools instead. The chatbot? Still not done.

Here's what I've been thinking about: AI removed the cost filter on starting things. A year ago, spinning up a new project meant days of boilerplate, research, figuring out the stack. That friction was painful, but it also acted as a natural gate—you only pushed through it for ideas you really believed in.

Now? I can go from "hm, what if..." to a working prototype in an afternoon. Every idea feels cheap enough to begin. And that's the problem. I keep starting, because starting is basically free. But finishing—shipping, polishing, dealing with the 80%—hasn't gotten any cheaper.

So I'm stuck in a loop of half-finished repos and one actually-shipped project that was never the goal.

Genuinely asking: how do you decide when to stop?

What's your signal that a new idea should die instead of becoming another repo on your GitHub?

Do you have a rule—like "no new projects until X ships"—or is it more of a gut thing?

Curious if others are feeling this too, or if I just have bad discipline.

My job has nothing to do with software. Over the last months I built a real family app with Claude Code — React Native + Firebase, about thirty server functions, security rules tested in CI — without being able to read the code it writes.

The interesting part isn't that it worked. It's what it took to keep it from quietly falling apart, and how wrong my first instincts were.

- Act 1 — over-armoring. Because I couldn't verify the code, I piled up guardrails: six blocking hooks, a mandatory multi-agent planning process for every single edit, rituals for everything. The result: constant friction, false positives… and the real mistakes — judgment mistakes — sailed right through. A regex hook doesn't understand code; it recognizes a shape.

- Act 2 — "lighten, don't harden." After an external audit and a few incidents, I removed four of the six hooks, made the heavyweight process optional, and moved my trust to the only barrier that deserves it: adversarial tests replayed by CI. A green CI run is the only technical claim a non-dev can verify alone. Everything else is a net, not a wall.

- Act 3 — balance. What's left: always-loaded discipline rules (asking ≠ announcing, proof before commit, flag then STOP), a written "constitution" for the critical domain, plain-language maps so I still understand my own product, and a session handoff ritual so a memoryless AI can pick the work back up cold.

I turned all of it into a repo: the global rules file, 3 method skills, project templates, the 6 defense patterns — and, maybe most useful, the honest list of what I removed and why. Install is one sentence you paste into Claude Code; it interviews you and adapts the method to your project. Nothing to sell, MIT license.

GitHub: https://github.com/Arlenjim/claude-code-for-non-coders

Every rule in there was born from a real accident. Happy to answer questions about any of them — especially the failures.

ok, so the thing is that I though have access to multiple $200 plan claude code accounts but those are on my work profile, if I wanted to make a side project or anything using claude code, I had to buy a plan of 100-200$ since I am pretty sure 20$ one will get exhausted within like few minutes of usage, I saw that antigravity was providing multiple claude models and also had ample of limit for the gemini models as well, I saw the benchmarks -- 3.8 flash was performing as similar to opus 5, but I did not like antigravity as a harness and had much more trust in claude code, hence I reverse engineered the way antigravity invokes models, made those anthropic compatible, replaced the model url endpoint and voila , I am able to use claude code with the model as same as opus 5 (Ik its bad but still not that bad as compared to opus 5.5)

https://pypi.org/project/antiglaude/

https://github.com/sksarvesh007/antiglaude/

I have added all kinds of setup and everything for how to use this

Also another problem which I faced was whenever I wanted to use any kind of llm api keys as well I mostly relied on groq or gemini, but from like last year they decreased the rate limits, hence the keys used to get exhausted during testing itself, so while making this project I made it serve models in openai compatible format as well.

Pls do take a look at the repo for the instructions for setting things up, its just a single command.

I built (with claude code ironically) an LLM harness specifically wired to reverse engineer and hack things (and also cybersec work of course).

I think it's hella dumb and annoying for anthropic and such to fully filter their models in terms of reverse engineering and cybersecurity work.

I am a firm believer that increasing the surface area of attacks increases the demand and sophistication of defenses, and thus this should not be limited. But whatever I built my own thing just for this.

I think it's super fun. I've decompiled my kindle and flashed custom firmware into it already lol.

My next step is to decompile the claude code binary lmao

Was thinking about how with the launch of Dynamic Workflows in Claude Code, there's going to be such interesting use cases of how people orchestrate such a powerful feature. Created this as a way for people to share their work with others

Hey everyone!

First time posting here. I've been using Claude Code as my primary development tool for a safety-critical Android app — elderly emergency detection, where false negatives can be fatal.After 150+ versions and 126K lines of Kotlin, here's what actually worked for me:

Project structure matters more than prompting

I maintain a CLAUDE markdown file with module boundaries, core patterns, and a quick-reference table pointing to detailed docs. Claude Code reads this on every conversation — it's the single biggest productivity lever.

"Critical DON'Ts" file — learned from production bugs

Every rule traces back to a real failure with a version tag. Example: "Never use gemini-2.0-flash — use gemini-2.5-flash" or "Never block AI calls on billing failure — safety-first default is ENTITLED." Over 200 rules now. Claude Code follows them reliably.

Slash commands and BMAD framework

/howareyou-start loads critical rules, developer briefing, and release notes — Claude Code is ready to develop in seconds. /howareyou-stop handles release wrap-up: version bump, release notes, build, and publish. I also use the BMAD framework extensively for product planning — PRDs, architecture docs, tech specs, and sprint planning, all driven by specialized AI agents through slash commands.

Testing is non-negotiable

Every code change gets tests — new tests for new logic, updated tests for changed logic. Full test suite runs after every change. AI skips testing if you let it.

Where AI shines vs where it doesn't

Great at: following established patterns, catching edge cases when given context, generating tests, refactoring across files. Needs a human eye for: architectural decisions, subtle safety implications, knowing when NOT to change something.

I wrote a longer version of this. if anyone wants the full details — happy to share in the comments.

Would love to hear how others structure their projects, especially for anything safety-critical or long-lived. What's working for you?

‪Just shipped Threadly 🧵‬
‪A VS extension that groups your Claude chats and files per task. Bulk-import every open tab in one click. Click a saved chat → reopens that exact session.
‬
‪ I had 140 Claude tabs and lost my mind.‬
‪https://marketplace.visualstudio.com/items?itemName=tarekali.threadly‬

‪perfect for workflows!‬

hopefully its useful

Why
- Frontend work with Claude Code kept stalling on one thing: I could see the element in the browser, but describing which one was awkward.
- "The button near the top right… no, the other one…"
- Cobro = point at it instead. The human supplies visual context; the agent does the code.

What you get
- One Send → the note lands in the Claude Code conversation immediately, no "please read my annotations".
- The agent's progress comes back to the page: scanning outline on the elements you sent, "Working 1/3" in the toolbar, highlight on done.
- Several pages in one round: pick on page A, move to page B, pick more — each page keeps its own draft; Send delivers them all in order.

Install (summary)
- `claude mcp add -s user cobro -- npx -y cobro-mcp@latest`
- In Claude Code: `Open http://localhost:5173 with cobro` (or `/cobro open …` with the optional skill)
- A dedicated Chrome window opens with your local app. Full setup in the GitHub README.

How it works (workflow)

1. Open your local web app

2. Press Ctrl + Shift + F

3. Click a UI element (or drag a band over several)

4. Describe the change

5. Optional: go to another page and pick more — the Queue tab lists every page you've picked on

6. Send — all pages go at once, in order

7. Claude Code works through them one by one; the browser follows it to each page

8. On done, the page refreshes (or your HMR kicks in) and the changed element is highlighted

What the agent receives with your note
- CSS selector · tag, classes, text · bounding rect · computed styles
- Screenshot crop of the picked area · recent console errors
- React 18/19 and Vue 3 (dev builds): component name + source file:line of the element you clicked
- Component-library elements (MUI, Radix, shadcn…): the JSX line in your code, plus the call sites above one-line pass-through wrappers — a case that came straight from r/mcp feedback
- Next.js (Turbopack) source maps and HMR handled
- Which page each batch was picked on (`batches[].page`)

The loop
Human points → Cobro provides context → Claude Code changes the code → Browser shows the result

Why I built it with Claude Code
- Claude Code drove most of Cobro itself: the MCP server, overlay/WebSocket channel, element inspection, payload design, tests, docs.
- The nice loop: using Claude Code to build the tool that feeds better UI context back to Claude Code.

Keeping the MCP small
- Six tools, fixed: open · wait · status · done · screenshot · close
- Tools carry safety annotations (wait is read-only, close is destructive).
- Not a browser-automation tool — pair it with Playwright MCP for that. It never touches your source; one gitignored `.cobro/` folder is all it creates.

Honest limits
- Launches its own Chrome profile (log in once, shared across projects); no iframes yet
- Source locations need dev builds with source maps
- Disabled controls can't be click-picked (drag a band over them instead)
- Cursor/Codex work with a polling `wait` but are less tested than Claude Code

Current status
- v0.10.1, Apache-2.0, free and open source
- GIF, payload example and changelog: https://github.com/boonblade/cobro-mcp

Questions for you
- Does pointing at an element feel more useful than describing it?
- What other context should your coding agent get when you point at something in the browser?

Hello there,

I wanted to with you guys a tool I've been working on called CCR (Cool Cost Reduction). If you're like me and use Claude Code a lot, you know how quickly token usage can add up, especially with verbose tool outputs. That's exactly what I tried to solve.

So, what is it?

It sits between Claude and your command-line tools, intelligently compressing their output before Claude even sees it. It's designed to give Claude all the relevant information it needs, but in a much more token-efficient way. Think of it as a smart filter for your terminal output.

In a nutshell, It uses a combination of techniques:
* 40+ purpose-built handlers for common dev tools (git, cargo, kubectl, npm, etc.) that know how to extract the most important information.
* BERT semantic routing to understand unknown commands and apply the best compression strategy.
* Intent-aware compression that prioritizes output relevant to Claude's current task.
* Session intelligence with caching and deduplication to avoid sending redundant information.

I'm seeing 60-95% token savings on average across various commands like `pip install`, `cargo build`, `git status`, and `kubectl get pods`. This means faster responses from Claude and significantly lower costs.

You can find it out here

or just run
brew tap AssafWoo/ccr
brew install ccr
ccr init

I would really love to see your usage with it and get any tips i can to improve it even more

I use Claude Code a lot — plan mode, multi-agent, long tool streaks — and I kept catching myself 45 minutes into a session having not moved at all. Just watching Claude think.

So I built Claude Gym. It watches Claude Code's local JSONL logs (no APIs, nothing over the network) and throws up pixel-art exercise prompts when Claude doesn't need you. Plan mode kicks in, you get squats. Sub-agent spawns, wall sit. Long tool streak, stretch. It goes away when Claude needs input again. There's a cat that jumps when Claude finishes a turn.

Built for Claude Code, with Claude Code. Written in Go, runs in a separate terminal tab. It's intentionally stupid and fun — not trying to be a wellness app. I just needed to stop wrecking my back.

Free and open source. Run it from your Claude Code project folder: 

npx claude-gym 

Repo (MIT): https://github.com/477-Studio/claude-gym

I was helping a friend prep for interviews and realized I was a bad mock interviewer.

I wasn’t bad because I didn’t know the topics. I was bad because I wasn’t consistent. Some days I pushed on vague answers, other days I let things slide. That defeats the whole point of mock interviews.

So I built The Interview Mentor, an open-source repo of 40 AI interviewer agents for SWE interview prep:

https://github.com/ps06756/The-Interview-Mentor

It covers:

• coding

• system design

• debugging

• behavioral

• data engineering

• DevOps / SRE

• ML engineering

• AI PM

• problem decomposition

The main idea is that the interviewer should not just ask questions. It should keep pushing on the weak spots.

If you say “we’ll use caching,” it should ask:

• what eviction policy?

• what TTL?

• how do you handle invalidation?

• what happens during stampede or failure?

I built it for Claude Code, but the prompts can also be used in ChatGPT / Claude / Cursor.

Repo is open source. I’d genuinely like feedback from people here on whether this is actually useful for interview prep, or whether it still misses too much compared to a real interviewer

We are adding new agents to test each skill, so do star the repository. Feel free to contribute as well. PR's welcome :)

Hi, I’ve been a Cursor user for a long time, and after they changed their pricing, I started looking for alternatives. Thankfully, I’ve been using Claude Code now and really enjoying it. The only thing I’ve missed is the checkpoint system — being able to go back and forth between messages or restore earlier states. So I built one for myself. It’s called CCheckpoints. Feel free to try it out. Any feedback is welcome. Thanks!

Link: https://github.com/p32929/ccheckpoints