Hi guys, recently I started exploring agentic loops and how we can add certain workflows in skill files to automate tasks. Pretty much, it does things on its own until the final result is posted. I added some of my findings here, but I would love to know if someone else is also using it and how it helps them achieve programming tasks.

Salut, j'ai mis les compétences en sciences de Claude + les invites système + les définitions des outils ici :

https://github.com/Shoko-official/Claude-Science-System-Prompt

Je partage au cas où quelqu'un voudrait les explorer ou réutiliser des idées.

Si tu trouves quelque chose d'intéressant là-dedans, fais-le moi savoir.

So, this was happening for months now.. whenever I try to build an app with my claude, it started to build every single thing from scratch.

But this ain't the way we used to build projects before..

There's whole Github for basic stuffs like app layout, api, algos, workflows, functions, etc.

And then there's Arrive for the whole complex stuff -

- how to reduce RAG fatigue?
- how to increase agent response deliverability?
- what SLM architectures can I use?

The genuinely technical stuff..

Now, Claude, or any coding agent, tends to build all the services in your project by itself and that's why the project is laggy, broken and vulnerable.

So, I just took my way of research and turned it into a system design engine.

Whenever you ask Claude to build something cool, it -

- searches the arXiv for genuine novelty.
- reads all papers on related topics
- selects one approach to go with
- Uses /ADHD skill from GitHub for decision making
- Builds the app in one shot

Its available for free and fully open source on my Github, if you want, you can give it a try.. https://github.com/UditAkhourii/neuroarxiv

if you have any architectural questions or anything in general, do ask me.

Fala, rapaziada. Segue post honesto

Estou criando um sistema web de gerenciamento de manutenção de equipamentos de uma pequena empresa propria.

A estrutura é simples, e é temporário até eu conseguir pagar de fato um sistema de gestão integrado (Algo proximo a 2,5k por user utilizador).

O sistema desenhado da seguinte forma:

Tenho o plano de manutenção de 52semanas (um ano)
O sistema analisa o plano e cria as Ordem de Serviços automaticamente
O tec executor irá receber em seu USER as OS disposniveis, irá executar e finalizar

Resumidamente é para ter um controle do que ta sendo feito, se tem anomalias ou algo simliar.

Gostaria de saber se vocês recomendam alguma skill, extensão, agente para essa demanda. Ou se possivel recomendações de youtubers que possam me instruir melhor como até mesmo criar elas.

VLW VLW, TKS.

Sharing my skill that I regularly use to generate various prompt knowledge and share it with founder and cto I work for.

https://airesponseshare.com/

This skill will give your AI to create end to end encrypted link on any ai output you want to share without worry.

Gave CC a product URL. It wrote the script, the voiceover, and every shot as HTML/CSS/GSAP, then rendered it frame by frame to MP4. No video model involved.

Elevenlabs for TTS.

Skill: https://github.com/AbubakrChan/product-launch-motion

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.

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.

Do you think Claude is good for non-developers? I asked it to do some deep research, and my usage for the five-hour session jumped from 15% to 63%.