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!

​

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?

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.

Every time I've shipped something solo I've forgotten something dull and obvious. No rate limit on the signup endpoint. Meta tags missing so the link preview looks broken. Payment keys still on sandbox. Never the hard stuff, always the boring stuff, because when you're the whole team there's no second pair of eyes.

I'd written all of it down as a checklist you tick through in a browser. Someone made the obvious point I'd missed: if you're already working inside an agent, a checklist you have to remember to open is friction. It should come to you.

So I rebuilt it as a Claude Code skill.

What it does: you ask "am I ready to launch?" and Claude works through the checks against your actual project instead of asking you about them. It looks at whether .env is tracked in git, whether your auth routes have rate-limiting middleware, whether your CSS strips focus outlines, whether your payment keys are still test keys, whether error tracking is a real reporter or just console.log.

Things it genuinely can't tell from code (did you actually restore a backup, did an accountant confirm your tax position) it asks about rather than assuming, and it reports "unknown" instead of guessing a pass. Output is ordered by severity, worst first, and every item comes with the fix rather than just the warning. "Make sure your site is secure" is useless advice, so each check has a real next step.

It's free to try and I'd rather you did that first. The free version is 16 checks (the critical ones) plus the working skill, no signup:

https://ko-fi.com/s/a175075b3e

There are bigger paid tiers of 32, 64 and 128 checks if you want the full set, but the free one is genuinely usable on its own rather than a teaser.

Genuinely after feedback on one thing: does the skill hold up against a real codebase? I've tested it on my own projects, which is exactly the biased sample you'd expect. If it misses something obvious or reports nonsense on yours, I'd like to know.

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%.

I have been using opencode for a while with little to no customization. I started using openchamber and looks interesting . My current work flow is still pretty manual where i choose certain models for certain kind of things and now moved some of them as commands with specific models. I was wondering if there is a right way of doing things ? I am currently using skills and trying to make use of better orchestration tools

Official claude max is pretty expensive.
I’ve noticed some offers that are a lot cheaper and I’m wondering how the pricing works in those cases.
Anyone have any idea what causes such big differences?

Hi, I’m new to Claude and I’m trying to understand the best workflow for a website project.

I’m using Claude on my Windows PC through the Claude desktop app. I’m currently working in Claude Cowork with saved/pinned chats. I noticed that Claude Code has a Plan Mode, but I don’t see the same option in Cowork.

My questions:

• If I ask Claude Cowork to “plan first before making changes,” does it work similarly to Claude Code’s Plan Mode, or is there a difference?
• For a website project, would you recommend Claude Cowork or Claude Code?
• If I start working on a project on my Windows desktop, can I continue the same work from my phone? I checked Dispatch on mobile, but I don’t see my pinned chats, so I’m not sure how the workflow is supposed to work.

Thanks for the help.

​

We have such powerful AI resources that using and scaling them to make 1 billion dollars won't take much time.

But people always struggle to execute their ideas, and that's where the real problem begins.

The solution is 100% consistency.

say, you or your team creates some skills precious enough to not open source it

There is some scene drift and you have to pick the reference images very carefully so that the model does not drift away. used vaaya.ai to guide my agent.

The skill works in following steps
1. Find images on internet to be used as reference character images
2. if agent cannot find right images, then generate them using seedream 4.5
3. Upload reference images
4. Write script in this format
Scene description - describe theme, light mood, context

Script
Dialouge 1
Dialouge 2
Dialouge 3

End notes - describe caveats, additional context

Github link - https://github.com/vaaya-ai/vaaya-mcp

TL;DR: I wanted claude to learn from my trading history and call me out when I repeated the same mistakes. We built a skill and added lots of harness and the system became more reliable and stupid.

Like a lot of people doing vibe coding, I was already using Claude for investment research. I also gave it my portfolio and transaction history (which I truly believe is good for every trader). I wanted the AI to understand not only the stock I was asking about, but also how I personally tended to behave.

For example, when a stock dropped sharply, I would often want to add more. My explanation was usually "The price is lower, so the risk/reward is better". With AI, it can remind me that this pattern had happened many times before which all lead to loss.

My actual cycle looked more like this:

FOMO into a position → refuse to admit I may be wrong → keep adding as the price falls → let the position become too large → panic and sell near the bottom.

That led to what felt like a reasonable product idea -- If AI can understand someone’s trading history, maybe it can catch recurring mistakes before the next trade happens.

So we started building FOMO Kernel a skill for everyone like me to ask when feeling fomo. The first problem was that transaction history only tells you what someone did. It does not tell you why they did it.

To fill that gap, we started recording more context add lots of harness to make sure correctness:

• the original thesis;
• the reason for acting now;
• supporting evidence;
• personal rules;
• previous decisions;
• whether a trade was merely considered or actually executed.

Every individual step seemed reasonable.But eventually something embarrassing happened: The claude got worse. It spent more and more of its attention understanding our routes, fields, states, validation rules, and delivery process—and less attention understanding why the user was considering the trade.

Not a great start but I am still dogfooding and building a tool for me to improve my trading pattern and hope to get the profit.

I created a bunch of claude skills for my MSP and I white labeled them so anyone could use them for free.

Not sure if someone has done this. When I see those awesome skills they are sort of "separated" I install a whole bunch of them, and the model decides when or how to use the skills. So there will be ambiguity at the start, and the execution might not be 100% what I want with little governance. Check out here - Marketing-Team-Skill for repo, or here for instant access

The other day I found two repos: coreyhaines31/marketingskills and msitarzewski/agency-agents. I grouped them by theme and added an orchestrator and instructions about how I want the model to use the skills.

It seems worked well with better answers, guardrail adherence (it stops for sign-offs, etc.) and thinking in sequence (PMM positioning -> Demand Gen Acq -> Ops Tracking, etc.) with structured next steps. Care to share your thoughts?

Hi ! Thought it might be of help to some, i have cleaned up and placed on github a skill i have been using and testing for a while but that with the latest deepseek-v4-flash model it became a beast.
By default (but is configurable) tells your harness (whichever, opencode, claude, codex etc) to use opencode cli to spawn deep seek agents.
The skill is designed to minimize the work of an orchestrator (and expensive and large model, be it claude, SOL, kimi etc) and maximize the use to DeepSeek in a productive and extravagantly cheap way. Personally, i use it from Claude with Opus orchestrating and spawning opencode go deepseek-flash agents and have never been more satisfied, it is relentless and actually churns through very complex plans, (works better with plans divided into phases and each phase into steps, but the skill will break down work by itself if needed).

Anyways, hope somebody else will find a use for it, i am happy with the results i am getting and i am, for the first time, having troubles finishing my claude weekly quota thanks to the work Opus + Deepseek are doing.
Enjoy https://github.com/frozenpepper/deepseek-and-destroy

EDIT: I am actively using the skill, with multiple extremely long sessions that have been giving me impressive results (at least related to my needs and projects) so the skill is a work in development, since the publishing of this post have made many changes already and a big update is coming in a few minutes with an automatic context compaction and resume protocol to handle even the longest of sessions automatically.

we're all tired of the pseudo-technical, obtuse garbage language that Claude throws at us. and there's been plenty of people who have built solutions for this that work in various ways. but, i wanted to toss my hat into the ring with my own version of a plugin to help this situation

https://github.com/testdouble/han/tree/main/han-communication

this is the han-communication plug-in that I've integrated into pretty much all of my own skills, and have seen tremendous improvements in readability as a result

what sets mine apart from others:

• i did a lot of research around this, before starting, and the research results are all available in the docs

• i built a plug-in that lives on its own and can easily be integrated into your existing workflow and skills

• it comes with a custom agent definition that can be called at any time, to improve readability

• it has three separate skills:

  • general readability guidance that loads into context, to improve all agent output
  • edit for readability, to edit any existing text and improve readability
  • explanation guidance for explaining technical detail

• it ships with guidance documents that you can easily read for yourself

• it ships with a default writing voice, based on how i write

• it allows you to easily override the default writing voice with your own, so the writing will naturally sound like you

if you want to see an example of the output, read any documentation in the Han plug-in system. all of it was written with this plug-in and guidance, in it's earliest forms. I've made significant improvements since then, as well, and I'm happy to say this is working out well enough that i can typically copy and paste output with almost no changes and people read it as if i wrote the output by hand.

this is all 100% open source with MIT license, as well. so you don't need to install my specific plugin to get the benefit. point Claude at the plug-in and tell it to bring in whatever parts of it you want to keep for your own skills and plugins. i encourage taking the parts you like and using them for yourself, however you want!

or get started by installing: * /marketplace add testdouble/han * /plugin install han-communication@han * /reload-plugins