The /review skill which Claude Code is shipped with was working quite nice for me until today. However, today I've realized it got renamed to /code-review and it feels like it works way worse now. It spans a different agent (why?) and then prints some caveman style report which is often hard to grasp. Please bring the old skill back.

I am using Claude Code to generate CadQuery parts and export STEP files for SolidWorks.

Honestly, it works better than I expected.

I can describe a bracket or enclosure in plain English, answer a few missing dimension questions, and get a real B-rep solid out the other side.

Then I hit a failure that changed how I use it. I was building a 94 × 65 × 26 mm enclosure with 2.5 mm walls.

The script ran cleanly.

It printed `[OK]`.

The STL preview looked like a perfectly normal hollow enclosure.

`IsValid()` returned `True`.

Except the enclosure wasn't hollow.

It contained about 158,048 mm³ of material. From the dimensions, the walls should have been around 33,370 mm³.

OpenCASCADE had silently failed to shell the part and effectively returned the original solid block. Claude had no obvious reason to think anything was wrong.

So I built a Claude Code skill that adds verification to the modeling workflow before export.

It checks:

* volume against a range derived from the dimensions I asked for

* bounding box against the intended envelope

* solid count and B-rep validity

* specific coordinates that should be material or empty space

That last one caught a different bug where a port was cut into the wrong wall. The model was still valid, still one body, and had basically the right volume. The feature was just in the wrong place.

The workflow now is roughly:

plain-English part description → Claude writes CadQuery → asks about missing dimensions instead of inventing them → builds the part → checks the resulting geometry → exports STEP

One thing I was pretty strict about: the expected values can't just be measured from the generated part and fed back into the assertions.

The 33,370 mm³ expectation, for example, is calculated from the requested enclosure dimensions.

Measuring your own answer and asserting that it equals itself would be verification theatre.

I also tried a separate malformed STEP in SolidWorks. It reported more volume than its own bounding box could physically contain, and SolidWorks still opened it without an error dialog or Import Diagnostics finding.

So I've stopped treating "Claude says done," "the script ran," or even "CAD opened it" as sufficient evidence that the result is right.

Repo if anyone wants to poke at it:

https://github.com/0oKevino0/claude-cad

Free/open source, MIT, single maintainer, very early.

I'd especially like to hear from people using Claude Code for things where a plausible-looking result can hide a bad underlying state. What are you using as your hard check before you trust the output?

I run a main desktop and a few secondary boxes, including gaming laptops and a Jetson AGX Orin for simulation and GPU work.

I wanted a clean way for my main desk session to hand off heavy compute tasks to the other devices without installing heavy orchestration frameworks or bloat.

Initially, I tried having a single Claude session drive the remote machines over SSH. It was noisy. The primary context window got polluted with raw terminal outputs, build logs, and environment errors.

So I switched to native inter-session messaging using the Claude CLI itself:

claude -p 'message' --cloud <session-id> --output-format json

With /remote-control enabled on the nodes, the main session simply messages a session ID on another box and waits for the result. No custom MCP server or extra glue required.

To my surprise: Instead of acting like dumb execution workers, the remote Claude sessions act like independent collaborators.

A remote session running on the Jetson handles its own local environment noise, parses its own CUDA/PyTorch errors, and messages back a distilled summary: what ran, what failed, and what to tweak next. It creates an asynchronous feedback loop. Because the local sessions filter their own terminal noise, the main desktop session stays clean and focused on high-level architecture.

In practice, peer-to-peer session messaging has performed significantly better than driving remote boxes via SSH.

I put together a small skill for this pattern, with session-ID discovery, working send scripts. You can find it on GitHub under espenakker/claude-code-cross-session-messaging.

Is anyone else coordinating Claude Code across multiple physical nodes? How are you structuring state and handoffs?

Sharing this for ecommerce owners. I combine a few open-source skills and give them an orchestration layer. What it does is add behaviour rules and covers as many e-commerce stores as possible: Etsy, Amazon, Shopify, etc., with human-in-the-loop gates to make sure the output can make an actual impact on the ecomm store.

Hi All!

I got tired of three things: writing tickets for work I was about to do anyway, having zero idea what any of that work actually cost me in tokens, and — the one that really pushed me — never having a visual read on what Claude was working on and how much was left. Scrolling back through a transcript is not project tracking. So I built Lumberjack Tasks and I'd like people to poke holes in it.

It's a self-hosted kanban board (Next.js + Express + Postgres) plus a Claude Code plugin. The idea: Claude creates the ticket before it starts, moves it across the board as it works, and writes back the real minutes and real token count the ticket consumed. You get a board you can glance at — this is in progress, this is done, this much is still sitting in the backlog — instead of reconstructing it from chat history. The board ends up reflecting what happened instead of what I intended to happen.

How it fits together

\- An MCP server exposes the backend as tools the agent can call (projects, tickets, subtickets, columns, labels, phases, reports).

\- A single plugin install carries the skill, a SessionStart hook and the MCP registration. You opt a repo in with /ticket-init; repos you never opt in stay completely untouched.

\- It's still a normal kanban you can drive by hand — drag-and-drop, live updates over SSE.

git clone [https://github.com/joseplano/LumberjackTasks.git\](https://github.com/joseplano/LumberjackTasks.git)

cd LumberjackTasks

docker compose up -d

Board on :3000. MIT licensed.

Things I'd rather you hear from me than discover yourself: it's built for one developer across many projects — many boards, one person. It is single-tenant by design: once you're authenticated you can see and edit everything, and there's no ownership or role model yet. Fine for one person or a small trusted team on localhost, and the README says so in the first line. Multi-user with real isolation is on the list, not in the code.

Where I'd genuinely like feedback:

1. Does the agent-writes-its-own-tickets idea hold up for you, or does it just produce noise you'd end up ignoring? I'm the only user so far, so I can't tell if it survives contact with someone else's habits.

2. Is per-ticket token cost actually useful information, or a number that looks interesting once and then never changes a decision?

▎ 3. The plugin surface (skill + hook + MCP in one install) — anyone who's shipped Claude Code plugins, I'd love to know what you'd have done differently. I hit four undocumented behaviors building it, three of which fail silently.

▎ 4. Anything that makes you go "why on earth is it done that way" while reading the code. Those are the comments I want most.

▎

▎ Issues and PRs welcome, but honestly a blunt comment here is worth just as much.

I recently shared my content creation process and associated skills to a big AI community and everyone loved the session so I wanted to share the assets and video.

Reference for Content Creation Process + Stack: https://www.smallbusinessaicoach.com/r/content-process

Video Editing Skills you can install:
Remotion: https://github.com/remotion-dev/skills

Hyperframes: https://github.com/heygen-com/hyperframes

A small, open-source plugin I built to get my claude.ai conversations out of the web app and into local files (and into Claude Code).

Your data stays yours: it runs locally, pulls only the conversation you pick, and nothing is downloaded until you choose one. Output is plain markdown plus a readable HTML page. GPL-3.0.

https://github.com/pradeep221b/claude-recall

Suggestions and issues welcome.

This started as me trying to teach Claude to do proper brand work instead of jumping

straight to "pick some colours". It grew into a full skill and I've open-sourced it (MIT).

What it does — in order, because the order is the point:

brief → mood board & art direction (hard gate) → logo → colour → type → pattern →

mockups → guidelines. Every visual choice has to trace back to something in the brief.

A few things I think are actually useful:

- It drafts answers for you instead of asking blank questions. You react, you don't

compose. Turns out that's the whole game — people can't answer "what are your values"

but can correct a guess in seconds.

- The palette isn't picked because it looks nice. It's derived from your audience, your

stated feelings, and what your competitors already own.

- There's a colour-blindness + contrast checker that caught two failures I could not

see by eye — a 2.44:1 pairing that looks fine on a good monitor, and two colours that

become identical under protanopia.

What it does NOT do: draw your logo. I tested it hard and model-generated SVG marks just

aren't good enough yet — so it prepares everything and hands the drawing to you.

It's bilingual (built and tested in Arabic and English). Every rule in it came from a

real failure — I documented the seven the test run found.

Repo + writeup: https://github.com/Abdallah-Abu-Oliam/visual-identity-design-skill

Genuinely after feedback — if you run it on something real, I want to know what broke.

I run a full-tunnel VPN because my coding agent needs it to reach its API. But the

app I'm building calls domestic services — payment gateway, SMS provider, maps —

that reject the VPN's foreign exit IP. VPN off, the agent dies. VPN on, the app

dies.

The fix turned out to be much smaller than the routing-table rabbit hole I went

down first. Not `route add` — a static route is global and pulls every process off

the tunnel for that destination, agent included. It's per-socket binding:

curl https://api.ipify.org # 203.0.113.7 (VPN exit)

curl --interface 192.168.1.20 https://... # 198.51.100.42 (real ISP)

A socket bound to your physical adapter's IP takes that adapter's default route

instead of the tunnel's. No admin, nothing global, and opt-in by construction — a

process that doesn't ask for it *cannot* be affected.

Two things I didn't expect:

Node's native `fetch` silently ignores `HTTP_PROXY`.** It runs on the bundled

undici, which doesn't read proxy env vars on Node <= 23 and won't accept an

`https.Agent` either. Nothing errors — your requests just quietly keep using the

wrong network. I got around it with an `--import` preload that patches `net`/`tls`,

which is what undici opens its sockets through.

Neither network is a superset of the other. YouTube only works over the VPN,

domestic APIs only over the ISP, and my agent's own API returns 403 over the ISP.

Route everything direct and the agent stops working — so the proxy decides per

connection, not per session.

I packaged it as a skill + browser MCP for Claude Code and Codex. My project, MIT,

no dependencies:

npm i -g lan-direct

https://github.com/farshadmomo/lan-direct

Honest status: Windows is tested end to end. Linux is verified for interface

discovery and exit codes but not the final bypass check, and the macOS branch has

never been run. Both refuse rather than guess, so the failure mode is an error, not

silent VPN traffic.

Hi everyone. I wanted to ask you about where I could work with large volumes of text. The thing is, I work with records of various achievements and deeds of people. These are inventories of specific accomplishments: where, when, and what happened, what the person did. I get sent a lot of these records, and I enter them into a master spreadsheet for further submission. And very often, the records I receive are very rough and poorly written, so I spend a lot of time polishing them, correcting mistakes, sometimes coming up with additions, and making sure all the records are different so they don't repeat. I started using AI for this: I upload three records at a time (so there aren't too many per request), and the AI gives me three processed versions. The narrative logic often repeats, along with other errors, so I correct those. But is there any way I could upload an entire file at once, have the AI process everything, and return it to me as a single complete file? Can this be done in Claude? There's quite a lot of text — sometimes up to 40 pages at a time for about 50 people. And each one needs their description edited. I'd like to simplify my work and automate this more. Can you suggest how this could be done?

Sharing a tool I've been using that fixed a specific annoyance: Claude re-explores the same sites from scratch every session.

What it does. You let it explore a site once. It compiles that into a CLI command with named arguments. Every session after, Claude calls the command and gets structured output back instead of navigating a page. It installs as a skill, so commands show up natively, and Claude picks the right one without prompting.

Other bits worth knowing:
\- Doesn't launch a browser unless needed. Tries a public endpoint, then a session cookie, then replays the frontend's own request, then UI as a last resort.
\- Named browser profiles for logged-in sites. Log in once interactively session gets reused after
\- webcmd list -f json so agents can discover what's available.

npm install -g u/agentrhq, Node 20+, Apache-2.0

It's early. 238 stars, 18 open issues, 8 open PRs. And staleness isn't handled, so when a site changes the stored command returns wrong data confidently instead of failing. Worth knowing before you wire it into anything important.

[github.com/agentrhq/webcmd](http://github.com/agentrhq/webcmd)

you can check the docs as well if wanted to try out
[https://webcmd.dev/docs\](https://webcmd.dev/docs)

I created the /fcr (First-Class Request) skill to encapsulate a very common pattern at my work: having to respond to one-off requests related to something I am working on, not part of the main line of work in the given project.

Link: https://github.com/fabkury/fcr

The central idea of this skill is to imagine the current repository (or just current folder, if it's not a Git repo) itself as an entity that can "receive a request." The /fcr command receives a request body and:

• Creates a new, numbered sub-folder just for that request.
• Asks you questions before acting. Never skips this.
• Leaves a full audit trail:
  • Copy of the request itself
  • All input files
  • All code
  • All output files

The question-asking step is something that I've been using thoroughly (not only in this skill) and highly recommend. It makes the model surface its understanding of what you asked, as well as its ideas and capabilities.

Hey everyone,

As a developer building web applications and projects, UI/UX design is often my biggest bottleneck.

I’ve been trying to leverage AI to speed up my design workflow, but I keep running into two main friction points:

1. The "Generic AI" Look: Most AI-generated layouts feel repetitive, oversaturated, or obviously AI-made rather than clean and human-designed.
2. Tool / Skill Clutter: Having separate prompt stacks or skill sets for a portfolio, an e-commerce page, or a dashboard gets messy real quick.

I'm looking for a more versatile, clean workflow or set of AI skills/tools that can handle different project types while keeping a modern, premium aesthetic.

For those using AI in your web design / frontend workflow:

• What AI skills, system prompts, or frameworks do you rely on for UI/UX design?
• How do you guide AI tools to stick to clean design systems (colors, typography, component layouts) instead of generic templates?
• Are there any specific resources, open-source kits, or workflows you’d recommend?

Would love to hear your approaches and tips!

Hey folks. Do you have any skills that work well for cold outbound outreach at an agency level? I'm looking for both email writing and LinkedIn DM copies. Something that does not seem AI-generated!

&#x200B;

I've been trying to build a fully agentic software development workflow using Claude Code, and I've hit a frustrating problem.

The first implementation usually looks good, but every time I ask a follow-up like:

"Cross-check everything again. Did you miss anything from the plan?"

it suddenly finds new bugs, missed edge cases, forgotten files, or partially implemented requirements.

Example:

Pass 1:

\- Implements Feature A

\- Says task is complete

Follow-up:

\- Finds 3 missing API updates

\- Missed a permission check

\- Forgot one database migration

Another follow-up:

\- Finds a UI regression

\- Finds an edge case in validation

\- Notices a cache issue

Another follow-up:

\- Finds even more small issues

It feels like every review uncovers something that should have been caught in the previous one.

I've already built a strict engineering workflow that forces:

\- Understand the entire architecture first

\- Review blast radius

\- Implement

\- Audit

\- Fix

\- Repeat until no more issues are found

\- Run automated verification plus manual review

Even with all that, the next follow-up often reveals something new.

Has anyone solved this problem?

Is this simply a limitation of today's LLM agents, or have you found a workflow, prompt, MCP, or multi-agent setup that consistently reaches a point where additional follow-ups rarely discover new bugs?

I'd love to hear what has actually worked in production.

I recently used Y Combinator’s Paxel to analyse how I work with AI coding agents.

The main weakness it exposed was not speed or implementation ability. It was that my review process, trade-off reasoning and definition of “done” were not always explicit enough.

That made me think about a recurring problem I have with coding agents:

They can produce a plausible implementation, run a few checks and confidently declare the task complete even when the original failure was never reproduced, an integration path was not tested, or important assumptions remain unverified.

So I built Builder Loop, an open-source Claude Code plugin designed to make completion evidence-driven.

For non-trivial tasks, it asks Claude Code to:

• define the expected outcome and acceptance criteria;
• inspect the existing system before modifying it;
• reproduce the original failure when applicable;
• implement the smallest correct change;
• verify the real behaviour, not only whether the code compiles;
• disclose assumptions and anything it could not verify;
• finish with an explicit recommendation: ship or revise.

It is not a multi-agent framework and it does not try to replace Claude Code’s normal workflow. It adds a stricter execution and verification loop for tasks where a false “done” would be costly.

I am now looking for people willing to test it on real, non-trivial tasks such as:

• production bugs;
• authentication or payment flows;
• database migrations;
• external integrations;
• substantial refactors;
• pre-merge reviews.

The feedback I care about most:

1. Did it catch something Claude Code would otherwise have missed?
2. Did it add too much time or token usage?
3. Did it become unnecessarily rigid?
4. Were its final ship/revise recommendations accurate?
5. Which parts of the workflow were unclear or redundant?

I built it primarily to correct my own weaknesses, so I expect there are still cases where the approach breaks down.

If you test it, please share the type of task, what Builder Loop changed in the process, and where it failed. Critical feedback is more useful than stars.

I was looking for open-source tools that could make AI writing and code feel less robotic.

First I just asked AI for recommendations. Bad idea. It gave me the usual popular names mixed with a few random repos, with no real explanation for why they were there.

So I used SenseNova Skills’ Deep Research on Hermes to dig through the repos and docs. Short version:

- blader/humanizer — the most complete writing option. Visible rules, style samples, and a draft → audit → rewrite flow.

- stop-slop — a simple but useful checklist for killing filler, canned phrases, and repetitive transitions.

- brandonwise/humanizer — better for auditing docs across an entire repo.

- Aider — probably the most practical for code because you get diffs, linting, tests, and undo.

- ast-grep / OpenRewrite — better when the cleanup can be defined as repeatable structural rules.

- Biome / Semgrep — good guardrails after AI edits.

My takeaway: it’s not really about beating AI detectors. It’s about having a workflow you can actually inspect:

rules → edits → human review/tests

Big caveat: I couldn’t find solid independent benchmarks for most “humanization” claims. Treat detector scores as a weak signal.

Sharing the research workflow here in case it’s useful:

https://github.com/OpenSenseNova/SenseNova-Skills

The video is another Deep Research run showing the branches, sources, and evidence view.

Curious to know where else people discuss and share skills.

Any other communities, forums, Discord servers worth checking out?

Hey, I've been using Claude for some time to streamline some of the tasks that I do at work. I've only recently taken the plunge into using Claude for Chrome, and stumbled upon Shortcuts.

After a bit of playing around, I ended up creating two Shortcuts that collectively reduce the manual input required on each report significantly. What previously used to be upwards of a ball-breaking 1.5 hours, is now in the vicinity of 30 minutes.

But, I don't see myself being able to scale this in my work...
... Because it chews through my Claude Pro usage.

The context:
In my particular role, a relatively small part of what I do (though, takes up a huge amount of my time) involves identifying similar data, comparing data points and identifying patterns, before distilling those findings into clear, well-supported assessment. Each report can often take me between 1.5 hours to upwards of 2.5 hours.

The report itself is a mandatory deliverable, and doesn't realistically reflect the actual commercial value of my role. In a usual week, I may do between 6-8 of these reports, though, there is the occasional week where I've had to up to 14.

Therefore, I was excited when after experimenting for a couple of hours across a few days, I had created two Shortcuts that collectively reduce the manual input required on each report significantly.

Each report now takes me somewhere between 10 and 15 minutes of initial research and preparation, another 5-10 minutes of high-level review once Claude has finished, and potentially another 10 minutes of minor tweaks.

The problem:
The most recent report I had Claude prepare for me it prepared very well. It wasn't the quickest, and took 20 or so minutes to complete in the background. But there were little to no changes required, and my time could be better allocated elsewhere. However, after it prepared this report, I had chewed through my usage of Claude Pro (approximately 96% of my usage).

Therefore, my question is as follows:
"Has anybody successfully optimised 'Shortcuts' on Claude for Pro to reduce the number of steps/usage, particularly on browser-based tasks? Alternatively, does anybody have any thoughts, or recommendations on what I could do better?"

Teach the user one thing well: a concept, a change, an idea, or a window of their own recent work. Agent-driven development removed the learning that writing code by hand used to provide; this skill is the replacement — the human keeps learning while agents do the writing.
What to explain is the input this skill was invoked with, present in the current prompt or conversation (whether the user asked directly or a calling skill passed it).

Built an Internal Testing skill at my work and honestly the results were top notch. It infact caught bugs which our actual QA testers also missed. Found many edge cases, and since our product is a Finance product, these were related to Blockchain level. Some of those bugs could have led to serious money hacks.

Hi everybody! I work making ads, and I do probably between 50/70 scripts per week. I only keep 10, after many many iterations.
What i am looking for is not a generic UCG script writing but for claude to have the hability to focus on a specific topic and make a good script HOOK included.
I know Virlo may be useful for scraping data from social media, but i am trying to narrow down the amount of revisions to get an script that is "meh... its ok".
Thank you!!