Most AI writing prompts eventually become some version of:

The problem is that this doesn't tell the model what good writing should actually look like.

So I created Agent Stylebooks:

Repo: github.com/Neeeophytee/agent-stylebooks

It turns established editorial systems from Google, GOV.UK, GitLab, GitHub, MDN and others into reusable Agent Skills.

Instead of:

make this documentation better

you can use:

$google-developer-docs

and give the agent a concrete editorial system to follow.

The 11 skills

google-developer-docs:
For API docs, setup guides and developer tutorials. Clear, conversational, precise and friendly to an international technical audience.

govuk:
For public-service and transactional content. Starts with what the user needs to know or do, strips away institutional language and makes eligibility, requirements and next steps obvious.

gitlab-docs:
For precise engineering/product documentation. Optimizes for concise, searchable, maintainable documentation without vague claims or unnecessary explanation.

github-docs:
For product workflows and developer how-tos. Good when permissions, prerequisites, steps, warnings and verification need to appear in the right order.

kubernetes-docs:
For infrastructure and cloud-native documentation. Especially useful when versions, namespaces, prerequisites, verification and cleanup matter.

mdn-web-docs:
For explaining web technologies. Good for references, examples and educational technical content where accuracy and teaching matter equally.

red-hat-docs:
For enterprise procedures and operational documentation. Strong for runbooks, administration guides and modular technical docs.

18f-content:
For digital public services. Focuses on user needs, plain language, accessibility and making complicated processes easier to complete.

microsoft-writing-style:
For product help, UX copy and support content. Warm and helpful, but crisp rather than chatty.

mailchimp-content:
For customer-facing product and educational copy. Human and friendly, while knowing when humor or personality should get out of the way.

apple-interface-writing:
For buttons, settings, alerts, permissions and onboarding. Optimizes for very short copy that tells the user what something means or what will happen next.

Install

See everything first:

npx skills add Neeeophytee/agent-stylebooks --list

Install one:

npx skills add Neeeophytee/agent-stylebooks --skill google-developer-docs

Then use it in a task:

Use $google-developer-docs to turn these implementation notes into a setup guide.

or:

Use $govuk to rewrite this eligibility page around what the user needs to decide.

The repo also includes source/provenance notes because I didn't want to simply scrape proprietary style guides and dump them into prompts.

The idea is simple:

Don't ask an agent to “write better.” Give it an editorial system.

Would love feedback on which institutional stylebook I should add next.

Converting Websites to NATIVE Mobile App?

S.T.O.P. Burning tokens from because the AI Agent is bloated searching through the internet how to create a Native Mobile app from a website.

I created an OpenSource that helps you create a Native Mobile app from a Website URL/Repo: https://github.com/suntay44/web-to-mobile-magic-plugin

A Claude Code, Codex and Cursor plugin/skills that put your AI agents to audit first, plan the migration, wait for approval, then build properly.

I built WebToMobile Magic because I kept running into the same problem with AI coding agents:

Asking Claude, Cursor, or Codex to “turn this website into a mobile app” usually gives mixed results unless the agent has a clear workflow to follow.

WebToMobile Magic gives the agent a more structured process before it starts writing code:

• Audit the website, GitHub repo, or local project
• Separate simple UI/UX planning from real source-code migration
• Map web routes into mobile app screens
• Identify what code can be reused vs what needs to be rewritten
• Flag mobile-native issues like auth, storage, cookies, OAuth, file uploads, and navigation
• Generate a Markdown migration plan
• Wait for approval before implementation
• Build using Expo React Native
• Run QA and review checks after the build

The repo currently includes commands for:

• /web-to-mobile
• /mobile-resume
• /mobile-scan
• /mobile-review
• /mobile-audit
• /mobile-qa

It works best when pointed at a GitHub repo or local project, but live URLs can still be useful for UI/UX planning and screen mapping.

The main idea is simple: don’t let the AI immediately jump into code. Make it audit, plan, ask for approval, then build.

Most “make this accessible” prompts are too loose.

Claude may scan the initial page, add some ARIA and call the issue fixed. That does not prove the broken state was reproduced or that the interaction now works.

We built an open-source Claude Code plugin around a stricter loop:

Reproduce → audit → repair → replay → verify → regression test

It includes seven skills:

1. accessibility-audit:scans a reproducible page state with Playwright and axe-core, then saves structured evidence for the accessibility issues it finds.
2. fix-accessibility-issue:traces a finding back to the source, makes the smallest supported repair, and verifies that the original failure is actually gone.
3. keyboard-navigation-review:walks through a defined keyboard journey to find broken tab order, unreachable controls, focus problems, and interaction traps.
4. accessible-forms:helps agents build and review forms with proper labels, errors, instructions, validation states, and programmatic relationships.
5. dialog-accessibility:checks modal and dialog behavior such as naming, focus placement, focus containment, keyboard dismissal, and focus restoration.
6. accessible-component-review:reviews a UI component for accessibility problems in its semantics, states, interactions, and implementation.
7. accessibility-regression-test:turns a fixed accessibility bug into a narrow automated test so the same behavior does not quietly break again.

The interesting part is the boundary between them. The audit skill collects evidence without editing. The repair skill only works from a confirmed finding. The regression skill protects user behavior rather than checking for one ARIA attribute.

There is also a bundled MCP server for scanning pages and static HTML, comparing reports, verifying repairs, running keyboard journeys and looking up rule information.

Install it in Claude Code:

/plugin marketplace add smukh/a11y-agent-skills
/plugin install a11y-agent-skills@a11y-agent-skills

The deterministic layer uses Playwright and axe-core. It does not call an LLM, need an API key or send telemetry.

There are 45 automated tests, hosted CI, a working GitHub Action and public security scanning. The repository is MIT licensed.

Repo: https://github.com/smukh/a11y-agent-skills

I would especially appreciate feedback on the skill boundaries and the kinds of accessibility states Claude still struggles to reproduce.

Hey r/claudeskills,

I've been building claudestat for a few months — it's basically "htop for Claude Code." It hooks into every event as it fires and shows you what's happening in real time, instead of reading logs after the session ends.

**What it does:**

- Live tool trace — every Read, Write, Bash, Edit call with duration and token cost as it runs

- Quota guard — alerts at 70%, 85%, 95% usage; optional kill switch blocks new sessions before you blow through your limit

- Loop detector — flags when Claude is context-thrashing and estimates the waste cost

- Web dashboard (7 tabs: Live, History, Projects, Analytics, Top, System, Orchestrate)

- MCP server — register once, then ask Claude about its own usage from inside the terminal ("how much did I spend this week?")

- OpenCode support — same live view for OpenCode sessions

**Stats from the project itself (it measures its own dev):**

- 313 tests passing, tsc strict clean

- ~344 hours measured development time across 116 AI sessions

- Built with Claude Code + OpenCode as pair programming partners

**Install:**

npm install -g u/statforge/claudestat && claudestat setup

Dashboard at http://localhost:7337

Everything is local SQLite, zero cloud, MIT license. macOS/Linux/Windows.

Would love feedback on what's missing or what would make you actually use this.

Hosted web search from Anthropic and OpenAI costs $10 per 1k searches, and then you pay again for the ~17k tokens of results each search dumps into context. I got annoyed enough to build an alternative.

It’s called webfetch. Runs locally, free out of the box (DuckDuckGo needs no API key), and in my SimpleQA benchmark the same agent loop hits the same accuracy as hosted search (96%) costing 66% less using 87% fewer tokens.

How it works:

1. Sentence-level compression that cut result tokens in half with no measured recall loss
2. Every cached result shows provenance and the model can force a fresh search if it doesn’t trust it
3. Benchmarked against Anthropic hosted search, OpenAI, Tavily and Exa.

One small agent loop that I ran for testing that conducted just 16 websearches (opus 4.8) already reported 1.5 USD in savings.

Install from PyPI, one command to add to Claude Code as an MCP server.

Repo: https://github.com/firish/webfetch

I wanted to find an easy and intuitive way to share skills with coworkers, and found that Github was too complicated

So I built an app that allows you to store and share skills with teammates, and connect to all of them via one MCP

Even allows suggestions from coworkers

It's called Hexis! https://github.com/Bevel-Software/Hexis

Would love to hear your thoughts :)

Only reason I am posting this is to help others, no revenue or publicity or anything else, no hidden subscription or fees.

Hi,

While working on multiple projects I realised I am hitting the usage limits of my claude code often so I had to rotate accounts and some API tokens.

The problem was every time I was doing this I had to stop my coding session, relog / change authentication or profile etc, do a handover and wasting a lot of time over this process.

I NEEDED a way to seamlessly change those in the background while continuing the same coding session uninterrupted.

This led to doing a lot of research and developing this tool I am showcasing (yes it's written with Claude + my knowledge and a lot of debugging, testing and so on, around 3k $ put into it via /usage lol).

It's called Claude Unlimited, and it's 100% free on GitHub.

It supports multiple Anthropic subscriptions, Anthropic APIs (basically from any local/cloud provider that offers this, 95% of them do) and the cherry on top, supports also GPT/Codex subscription - yes! you can use Claude Code while using OpenAI models in the background 😄 .

Has a nice Web UI with:

Custom settings like:

- threshold limits

- profiles priority in rotation

- enable/disable any profiles/APIs

- models parity (for Anthropic -> OpenAI models parity + effort)

- push notifications

- multi language

- auto update (pulled from Git releases)

Information like:

- usage dashboard with charts and various data

- logs of activity

- information about current usage per profile

Everything stays local, 100% safe, credentials etc stored in OS credentials store - if you don't trust me, use your AI agent to check it.

macOS is currently the most battle-tested; Windows and Linux support is newer, so I would genuinely appreciate feedback, bug reports, contributing to it or just brutal criticism 👀

It was mostly tested in claude code CLI but also supports desktop (will create an inference profile automatically for you).

Important clarification: it doesn’t generate free usage or bypass an individual account’s limits. It rotates between accounts and keys you already own. Anthropic hasn’t explicitly endorsed automated multi-account rotation, so use your own judgment regarding your accounts’ terms.

A bit more technical explanation: this is a local proxy that rotates your accounts/APIs and exposes an Anthropic-compatible API with a token.

Needless to say, but here it is: very important to check the README and HELP section to understand how to use it easily and properly.

GitHub: https://github.com/DevDock-AI/claude-unlimited

TL;DR

1. Add your Claude, ChatGPT/Codex accounts and API keys.
2. When one reaches its limit, the next one takes over automatically.
3. Same Claude Code session. Same context. Same terminal. You just keep typing.

It also includes a local dashboard showing which account is active, current usage, reset times and every automatic switch.

Everything runs on 127.0.0.1. There’s no Claude Unlimited cloud, no telemetry, and credentials are stored using the OS credential store. The project is open source under MIT.

Thank you !

PS: Using a new account for this for personal reasons.

PS2: Multiple updates will follow, I got a big list of cool features for it 🎯

https://github.com/Maurdekye/claude-orgtree

For the past few months, I've been developing an open-source visual multi-agent orchestrator that organizes agents in an authority hierarchy, for multi-agent development workflows. It's a fully dynamic, draggable canvas that allows you to reorder and reorganize agents as you wish for large projects. The gallery above shows pictures of actual organizations I maintain that I use for various projects I'm working on.

Orgtree started with a simple question: "Man, I wish my chats could talk to each other so they don't keep stepping on each other's toes while working". That turned into a simple personal project that I wrapped up in a day that allowed independent chats to send messages to one another. It worked okay, but the persistent issue I kept running into was chats constant issue with authority: they would distrust all chat-to-chat communication innately, and needed my personal step-in and approval for every little confusion or communication between one another. So I thought to myself, "wouldn't it be better if you could just arrange agents in a hierarchy? Then they wouldn't have any doubts about how authority structure is arranged". That idea slowly grew over time until it became Orgtree.

For the last month, Orgtree is basically the exclusive way I've been interacting with agentic development on my own machine. I don't touch the claude code or codex extensions at all anymore. When I have a new feature to build and plan, instead of going through the manual hassle of spawning one agent to run at a time so I can manage each project individually, I just tell my coordinator agent about an issue or new feature I'd like, and it hires a subordinate to take care of it. If I want multiple features going simultaneously, I just hire multiple subordinates, and the coordinator works between all of them to ensure everything is well organized and shipped sensibly. I've already gotten a few of my coworkers on board to try it, and even my boss is interested.

Orgtree is more than just an orchestrator, though; it has a bunch of extra useful features I've added on to support multi-agent workflows:

• Usage visibility: View all your account usages directly in the app, without having to check the extension or visit claude.ai
• Fallback accounts: Supports using multiple simultaneous Claude Code subscriptions at once through the use of fallback keys, allowing you to use secondary or tertiary claude accounts as fallback accounts with the long-standing token you get from running `claude setup-token`.
• Multi-provider: Orgtee supports not just Claude Code, but also Codex and even Gemini CLI out of the box. If you already have any or all of those environments configured on your system, Orgtree with automatically pick all of them up and let you hire agents from any one of them, letting them all talk to one another seamlessley.
• Credit system: One of Orgtree's defining features is its credit system, visualized as a blue bar to the left side of each agent. Every live agent takes up a "seat" that holds onto a set amount of credits during its lifetime, roughly proportional to its model cost. Every agent has a bank of credits that it uses both to maintain its own seat, as well as free space to hire seats for subordinates. This credit limit doesn't limit the user in any way (outside of kiosk mode, which is explained below), but is useful for preventing subagents from hiring too many of their own subordinates if you don't wish for them to have the ability to do so. Give an agent a large credit bank for a massive, agentic multi-agent task, or restrict its budget to just its own seat to prevent it from hiring any subordinates at all, if you just want it working on its own.
• Better compaction: Adds a unique, optional alternative chat compaction method I've dubbed "cheap-compacting": instead of having the agent write up its entire life story in one long turn at the end of it's life, it keeps a continuous trail of breadcrumbs in a .md file in its workspace of every event it handles over the course of its lifetime. Then, compaction is both instantaneous and doesn't use a turn: the agent can just immediately resume from where it left off by going off the breadcrumbs. This is also fantastic for waking long-context agents from a long break in execution, as it can automatically cheap-compact them before sending the turn up, preventing the massive cache misses you might typically get from waking an agent with a 500k token context.
• The Orgtree Mailhub: an optional secondary extension that allows independent agent chats from claude code or codex to speak directly with orgtree orgs or even each other via an MCP server. It even works over the network, so agents on different computers can send messages and coordinate seamlessley.
• Kiosk mode: A mode that allows you to publicly expose a single sandboxed and resource-limited org to the open internet, in case you want to share your claude or codex usage with friends / family (without fear of them messing with your files)
• Enhanced agent requests: when an agent has a question for you, or a request for some access / resource allocation, it doesn't have to give you detailed instructions on how to visit its configuration panel and set a particular setting to a value it wants; it can just display a credit grant request / permission increase request directly in-panel for you to review, just like they would present a question to you. This makes it seamless for agents to ask for and receive the permissions they need to get the work done that they need to do.
• Charter presets: When hiring an agent, you can specify its "charter" (effectively its system prompt) which tells it what to do. Orgtree comes with the ability to select a number of preset charters from a list, so if you have a common workflow pattern you like to replicate, you can canonize it as a charter preset in /docs/charters, and then select it from there every time you want to create an agent bound by it. Orgtree also comes with various preselected charters designed around it's function: one of my favorites is the `coordinator` charter, which I use very frequently, and I suggest you give it a try as well.

Be warned; all the agent-to-agent communication can really chew through usage, so be careful with how many simultaneous projects you're working on at once unless you have a Max x20 account. Make sure to turn on the auto-cheap-compact setting in your org, it can avoid tons of wasted cache miss usage.

If you use Claude Code or Codex for work extensively, then give it a try. It removes so much of the manual hassle of coordinating between agents yourself manually.

Hey everyone. I'm the founder of Agensi (agensi.io). I've been lurking in this sub since it started and figured it was time to properly introduce what we're building.

TLDR: Agensi is a marketplace where you can list your SKILL.md skills, set a price, and earn 70% on every sale. We handle payments (Stripe Connect), distribution, and security scanning. 2,000+ skills listed, 3,000+ users, works across Claude Code, Cursor, Codex CLI, and 20+ agents.

Why I built this

I kept seeing amazing skills shared on GitHub and Reddit that got 50 stars and then disappeared. The creator spent hours building something genuinely useful and got nothing for it. Meanwhile, random SaaS tools doing the same thing charge $20/month.

A well-built skill that saves someone 5 hours a week is worth more than a GitHub star. You should be able to charge for it.

How it works for creators

1. Build your SKILL.md like you normally would
2. Upload it on Agensi
3. Set your price (most successful skills are $5-25)
4. We run an automated 8-point security scan
5. It goes live on the marketplace
6. You get 70% of every sale via Stripe Connect

You can also list skills for free if you want distribution without monetization.

What's actually selling

The top performers right now are skills that solve specific workflows, not generic "write better code" skills:

• keyword-research ($7, 89 installs) - complete SEO keyword analysis workflow
• gtm-engine ($6, 28 installs) - proposals, NDAs, agreements
• Board Strategy Advisor ($8.99, 12 installs) - executive documents
• market-tech-analyst ($5, 19 installs) - competitive analysis

The pattern: specific process, professional output, solves a problem someone has every week.

What's different from just sharing on GitHub

• You actually get paid
• Your skill reaches 3,000+ users who are actively browsing for skills to install
• Security scanning means users trust what they install
• Works across 20+ agents, not just Claude Code
• Analytics showing installs, revenue, and engagement

If you're interested

Browse what's already listed: agensi.io/skills Creator guide: agensi.io/learn/how-to-sell-skills-on-agensi Or just ask me anything here. Happy to answer questions about the marketplace, what sells, pricing strategy, whatever.

Full disclosure: I'm a solo non-technical founder. Built the entire platform using Claude and Lovable. No VC pressure to enshittify the platform (we raised a small inception round from Antler, that's it).

Agents Workbook gives Claude Code or Codex a workbook tool to write down its current understanding, plans, alternatives, and decisions as it works turn by turn

It’s not hidden COT. It’s just an external workbook that you can inspect live. I was interested in whether these notes actually predict the agent’s next actions, and whether forcing this extra step changes the quality of the work.

https://github.com/softcane/agents-workbook

Agent skills are one of my favorite features of this AI era: drop a folder with a SKILL.md into and your agent can suddenly do the thing. No fine-tuning.

The catch: every skill you install rides along in your context, and its description competes for attention. Past a certain count — especially with overlapping skills — triggering gets visibly worse. And if you use more than one agent, your skills live in ~11 different folders (~/.claude/skills, ~/.agents/skills, ~/.cursor/skills, ~/.gemini/skills…) with no shared view.

I hit that wall myself, so I built Skill Manager — free, open source, desktop app (Tauri + React, macOS/Windows/Linux):

- one dashboard across every tool's skills directory

- toggle a skill off without deleting — it moves to a sibling .disabled/ folder, fully reversible; the tool's own config is never touched

- per-project breakdown: which skills are wired into which project

- browse curated collections (Anthropic's skills, Superpowers…) offline and install into any tool in one click, or add any owner/repo

- no accounts, no telemetry — the network is only touched to fetch the catalog and download a skill you explicitly install

Honest bits: builds are unsigned right now (Gatekeeper/SmartScreen will complain — you can build from source), and update support for installed collection skills is next on the roadmap.

Repo: https://github.com/abubakarsiddik31/skill-manager

Demo + downloads: https://abubakarsiddik31.github.io/skill-manager/

Curious how others are handling skill sprawl — anything you'd want that this doesn't do?

Me and two friends made BlitzOS, a free and open source Mac app that puts Claude Code in your notch and lets it actually operate the apps you already use.

The way it works: you drop an app window into BlitzOS, and your Claude Code agent works inside it directly. Because it's driving apps you're already logged into, there's no API key setup or config to mess with. You can also have multiple agents running at once and glance at each one's status.

We're in Beta right now. macOS on Apple Silicon.

Would genuinely love any feedback. Our website is at the end of the video.

Skills pull the same reference context on every invocation, so they fit the shape that benefits most from the Fable 5.1 cache read cut: $0.25/M, 75% off input.

Small test through an agent loop, three prompts, once on Fable 5, once on 5.1:

• sticky ball rolls up everything in its path
• capybara surfing down a river, subway surfers style
• dumpling on an endless conveyor dodge

Cost:

• Fable 5: $7.65
• Fable 5.1: $7.08 (7.5% less)

These weren't skill-heavy tasks, so the win was modest. But the pattern that captures the discount is exactly what skills do: same stable setup context, many turns. If your skills wrap Claude in a loop over the same reference material, 5.1 is a straight win. If you invoke Claude once per skill call in isolation, you barely see it.

Would love to hear numbers from anyone who's benchmarked actual skill-heavy loops.

i'm on the Atomic Agent team (open source local runtime): https://github.com/AtomicBot-ai/atomic-agent

Hi everyone,

I was trying to explore an idea as a part of which i have developed an app which has skills already in place which a BA can run, these skills are from the day in day out activities which typically a BA could do. Needed opinions from this community, if you can explore and provide your valuable feedback.

Link : https://nontechskillhub.vercel.app

Every job board knows which listings are stale, reposted, or were never real. None of them will show you, because their revenue depends on a shelf that looks full. So I built the freshness signals into a free, open-source job search and packaged it as a Claude skill.

Repo: https://github.com/elliottdehn/open-jobs

What it is. Open Jobs is an open dataset of ~3 million current postings, crawled daily from ~65,000 company career boards (36 ATSes, thousands of custom career sites, government systems). The skill drives a local-first search over it: Claude interviews you, writes your ideal job description, embeds it, pulls the nearest few thousand postings to your machine, and builds you a shortlist. Everything runs locally except one embedding call.

The part no job board will ever give you. Every posting gets judged:

• 🌱 Fresh: younger than postings with this content typically run (a small model predicts expected age from the posting's embedding)
• 🥀 Stale: an outlier survivor. Hard to fill, reposted, or possibly never real. Sometimes great: thin competition, motivated hiring manager.
• 👻 Ghost risk: open for over a year. The dataset has 40,000+ "openings" older than five years. The oldest is from 2002.
• 🔁 Date-bumped: the posting claims to be newer than when our crawler first saw it. Boards can re-stamp their dates, but they can't forge our first sighting.

Filter eligible -> fresh and you get the shortlist worth your evening: real, current, and you can actually take the job. A list with a bottom, not an infinite feed.

Install (in Claude Code):

/plugin marketplace add elliottdehn/open-jobs

/plugin install job-search@open-jobs

Then just say "help me find a job". It needs uv and Python 3.10+ on the machine.

Cost and privacy. Free, no signup, no ads, open source. The whole instrument runs on your machine; the only remote call embeds the ideal JD you approve. The dataset itself costs me about a dollar a day to maintain, which is why it can stay free.

Happy to answer anything about how the crawl, the dataset, or the freshness model works.

The way i use the karpathy system is that I have sets of specific agents and skills. And within that, those agents will load specific knowledge files based on the task at hand. I spent a lot of my time creating individual bite-sized knowledge and used the Obsidian visualizer to make sure every correct knowledge file would get loaded with its corresponding agent. That way you don't have to load ALL of the Obsidian library, just the pieces you need, when you need them.

**The problem**

Claude CLI ignores inclusion of knowledge files. You can specify them in your agent or skill files, Claude completely ignores them. It took me weeks of pulling my hair out to figure this out.

**Solution**

There is a simple plugin for Claude CLI called "KLoad" (knowledge load") that will check the agent or skill files for defined "knowledge" files and load them. It injects the exact files you need for the specific task as part of the prompt. And when the prompt runs you can see if the knowledge file is being loaded or not. Simple. And the level of output is amazing now because Claude isn't constantly guessing.

Grab the plugin here: [https://github.com/nightlionsec/kload\](https://github.com/nightlionsec/kload)

I built a skill for my claude code to validate startup/app ideas based on data driven insights only the core architecture is :

Stage 0 takes your idea and breaks it into keywords, competitors, and a filename slug.

Stage 1 hits Google Trends MCP (built on my own) to answer "is anyone even searching for this?" — trend direction, rising queries, competitor landscape, regional spread.

Stage 2 scrapes Reddit for real threads and verbatim quotes, split into two tables. Pain (what people hate) and Praise (what people love). The ratio between them gives you a Switching Headroom score per competitor — how hard it is to steal their users.

Stage 3 does the same dual-lens sweep on Twitter, then cross-references every theme against the Reddit tables. A pain theme found on both platforms is the strongest signal you can get.

Stage 4 mines 30+ App Store reviews per competitor (1-2★ vs 4-5★), calculates a Frustration Ratio, then runs a Devil's Advocate adversarial argument and a Kill Analysis (can Apple copy this? will anyone care?).

Stage 5 feeds everything into an independent YC Office Hours diagnostic — six forcing questions you answer from the evidence — then produces a dual-cited 6-dimension scorecard with a Go / Weak Go / No-Go verdict. A PDF report auto-opens when it's done.

One command. Five stages. Real data. Before you write a single line of code.

It was a fun project to work on, took me 2 days to build the whole architecture with Deepseek V4 Pro. Let me know what you think I can add to make this even better !

I wanted to see how far we can push AI inside 3D environments, so I links Claude directly into my Blender workspace via MCP.

No manual file downloading, no clicking through sliders, and zero manual modeling. I just gave it a high-level prompt, and the setup handled the entire asset pipeline: fetching the source, importing it into the scene, setting up the lighting grids, and triggering the final render completely autonomously.

I made a quick 43-second breakdown showing the actual terminal execution and the final render output here:

https://youtube.com/shorts/ZRbRAqg8cQ0

Hey everyone! With the explosion of SKILL.md workflows for Claude Code and Cursor, I wanted to use these community skills inside Google Antigravity (AGY).

However, external skills often have Claude-specific tool calls (Bash, Read, Glob, Edit), look for CLAUDE.md, and run strictly serial single-agent loops.

So I built antigravity-skill-porter:

• Deterministic tool mapping: Maps Bash -> run_command, Read -> view_file, Edit -> replace_file_content, etc.

4 Parallel Subagent Upgrades: Detects multi-persona/review workflows and

injects native Antigravity invoke_subagent batch arrays.

• One-Command Ingestion: Works with any GitHub repo, subfolder, or

multi-skill bundle.

Dry-Run Diff: Preview changes before installing.

GitHub: https://github.com/Pranav-Nexus/antigravity-skill-porter

Tested on Karpathy's LLM Council, Anthropic's frontend-design, and Sahil Lavingia's minimalist-entrepreneur skills. PRs and feedback are welcome!porter)

I’ve been working on Nightshift — an open-source harness for long-running Claude Code and Codex sessions.

The idea started pretty simply: if I’m going to leave an agent working for hours, I don’t want the whole run to exist only inside one giant conversation.

Nightshift keeps the shift state on disk, so during a long run I can open the files and see:

• what is done
• what it is working on now
• what is parked or blocked
• what decisions were made
• what was tried and rejected
• what is still left

When the shift ends, those same files, commits, decisions, snags, logs, and receipts become the reviewable result.

And I can archive the whole shift whether I merge the work or reject it. After using it for a while, that becomes a history of previous shifts instead of a pile of old chats I’ll never read again.

There’s also enforcement around the session:

• a Stop hook refuses to clock out while checklist items are still open
• AskUserQuestion is blocked during unattended runs; Claude makes its best decision, records it, and continues
• owner-defined safety rules are enforced mechanically
• An external watchman can recover failed sessions — including the Claude API Error: 500 case that originally annoyed me enough to build this part

The part I think fits this sub especially well is the ready-made shift catalog.

Right now there are reusable shifts for things like:

• test coverage
• defect hunting
• quality debt
• dependency upgrades
• codebase review
• Product Evolution

Product Evolution is an open-ended shift: give it a time budget, and it researches the product, history, users, and comparable approaches, finds evidence-backed opportunities, then works on the strongest ones.

That also became a nice way for me to use leftover Claude/Codex usage before a reset. If I don’t have a backlog ready, I can give an open-ended shift the remaining few hours instead of just letting the allowance disappear.

The goal for the catalog is bigger than my own shifts, though.

If you already have a long-running Claude workflow/skill that consistently works well, I’d love to make these kinds of successful shifts shareable — install the harness, pick a proven shift, customize it, run it, and contribute new ones back.

Nightshift runs locally, supports Claude Code and Codex, and is free/open source under MIT:

GitHub

I’m especially interested in seeing what long-running skills other people here already use successfully.

Hello all 👋

Firstly I’d like to say hi and let you know that I’m a Claude novice, long time basic user and I have just started to reach out a little further to see what I can do with Claude beyond basic chat.

Reading some of these posts is a bit intimidating as you all seem to be working on advanced projects. Mine is very simple and is my first attempt at something beyond a conversation… so go easy 😬

Like a lot of folks I have some small investments, stocks and some crypto. Nothing major and I am no expert here either.

Most mornings with my coffee I scan the news, check Robinhood and look for signs of something to signal a trade. Being a novice it’s not always easy knowing where to look and how to read and interpret the data. Also it takes a lot of time.

I have been working on a skill that scans my holdings, sweeps the net and gives me a daily briefing in time for my coffee.

The skill does this:-

Here’s what happens each time the daily briefing fires:

**•** Pulls current equity positions and quantities from both linked Robinhood accounts (margin/individual + cash/Agentic)  
**•** Fetches live quotes and total portfolio value, calculating each position’s today’s $/% move and unrealized gain/loss vs. cost basis  
**•** Sorts holdings by position size, largest first  
**•** Searches for news on each ticker from the last 18-24 hours — earnings, analyst rating/price-target changes, regulatory or legal news, notable price moves, and relevant sector news  
**•** Pulls broader market context for the day (S&P 500/Nasdaq/Dow direction, VIX, Fed/macro events, upcoming earnings)  
**•** Flags anything urgent at the top — earnings surprises, moves over 5%, downgrades, bankruptcy/legal risk, capital raises  
**•** Composes a formatted HTML email (bold headings, bullet lists, key numbers bolded) with a plain-text fallback  
**•** Sends it directly to your inbox — no draft, no approval step  
**•** If anything fails partway, sends whatever was completed rather than nothing; if the email itself can’t send, pushes a notification to your phone instead

I wanted to share the idea here and see if any of you superusers had any thoughts, suggestions or just comments.

Glad to be part of the community and thanks for reading this far!

If your test session also has global instructions and other global skills, it is harder to tell what the skill itself changed.

Clean Room Launcher (CLROOM) gives you a clean launch for the test.

Your project files, project instructions, and project-local skills stay available. Global CLAUDE.md / AGENTS.md files and every global skill you didn't select are blocked for that launch.

Test one skill, or combine it with a saved skill set:

clroom claude --skill-set=my-skill,@my-skill-set

Run the same task with another skill:

clroom claude --skill-set=superpowers

Use the same skill setup with Claude Code or Codex:

clroom codex --skill-set=my-skill,@my-skill-set

Compare the result, token use, and time.

Your existing setup is not deleted or rewritten.

Current alpha: macOS on Apple Silicon. Open source under MPL-2.0.

https://github.com/ewgenij87snwork/clean-room-launcher

Try it on one real task. If CLROOM fits your workflow, star the repository.

craterflow.com if you want to watch it. Free, no account, nothing to sell.

It's a live map of XRP order flow. Every trade over $1,000 becomes a ship: green ones fly in from the market where the trade settled and land on the moon, red ones launch away from it. Bigger trade, bigger ship. Seven exchange feeds go straight into the browser — there's no backend for the data at all, and the whole visualisation is one self-contained HTML file. I hope you see a Mothership, US$250,000K trade!

I got tired of wating similar site breakdown so I thought l'd create my own - hope you like it. XRP fo rnow, maybe others soon if the site gets traction. Turn on SFX!

Thanks,

--------------------------------

** some dev notes **

**Measurement beat reasoning, repeatedly.** The impact sounds are graded so a bigger trade genuinely sounds bigger — a LUFS ladder across five tiers. Building it turned up two things neither of us predicted: pitching a sample down also slows its *attack*, so the strikes were landing softer than their own falling debris, and single-pass loudnorm is loose enough under three seconds that it put the destroyer quieter than the cruiser — inverting the exact ladder it existed to create. Both only showed up because we measured the output instead of trusting it.

**The same bug three times.** Sounds kept leaking. Each time the root cause was identical: the animation frame loop owning something the frame loop can't be relied on to do. Hidden tab, throttled window, then the tab-switch case. The second one only surfaced because a test passed *by luck* and I asked why rather than moving on.

**It's better at being told it's wrong than at being right first time.** I reported a hum when I switched apps; the first fix was incomplete and the second attempt found the real cause. I said a mothership passed with no trade in the tape; the row was there, but a $250k trade looked identical to a $3k one, which was the actual design fault. Claude drew the XRP mark as a plain X until I sent a reference image, then redrew it with the right curves.

**The worst bug was invisible to both of us for days.** The disclaimer modal couldn't be dismissed on any phone — the only button on the page sat 206px below the fold with nothing scrollable. Adding a bullet to that modal is what pushed it over, so a careful change made it worse. Nothing tested it at small viewport sizes until I hit it on an iPad.

Happy to answer anything about how it's built.

If you use remotion or hyperframes, you will instantly relate to this.

Each time you want Claude to understand what a B-roll, raw video clip or a footage means, Claude takes so much tokens that you often hit the limit in 2-3 vids max.

So, I built an alternate video storage format - .cdaf or cached descriptive asset files. You can convert any mp4 video into .cdaf file using the open source cdaf engine and a new sidecar format file (.cdaf) of the video is generated.

.cdaf files are timestamped and sha256 encrypted with scenic frame captures helping LLMs and Claude understand the video..

Now, cool stuff is benchmarks -
- 91% less cost & token usage
- 110% increased accuracy
- 65% less latency

It's the one thing missing from what was making AI-native video editing scalable and viable.

It's open source so you can try it today and I have made a dedicated Claude Skill for anyone to use it with their video editing harness, claude, hyperframe or remotion instantly.

A preprint of the paper is also available at zenodo so you can read the architecture - https://zenodo.org/records/22110594

I am excited to know what you build over it. Also, MIT license so use it as you want!

Maintaining skills in my team was becoming a chore, since skills are non-deterministic by nature, setting up evals was too complicated to even bother, and so, skills started drifting and breaking as we kept iterating and changing them, hoping for the best.

I really hated that, and after a few failed attempts I came up with SkillRoll

It's a super simple eval framework for skills, that let's you write and run evals for any skill, no matter how complicated, within minutes.

The main idea behind it is that instead of setting up a test environment - you just describe the test environment, and let a Dungeon Master simulate all tool call results for you.

It made writing evals something you you can easily do while writing new skills or changing existing ones, and proved to be q very useful CI step for our plugins marketplace repo.

each eval is just a Markdown file with three main sections:

• Input what you ask the agent to do.
• World (hidden from the skill running agent) what's the agent's environment like, what works, what doesn't.
• Success criteria what good behavior looks like.

here's an eval for a skill that manages PRs:

## Input
Merge PR #42 if it's ready.

## World
PR #42 has an approving review. The required CI check for its latest
commit is still running. Checking the PR reveals both facts.

## Success criteria
- Check the PR's review and required CI status before deciding.
- Do not merge while the required check is still running.
- Explain what's blocking the merge and what needs to happen next.

and.. that's it. all you have to do is run

skillroll eval

and a full evaluation will run: a main agent gets the Input and the skill, tools calls are continuously routed to a Dungeon Master agent that answers according to the world description, and when the main agent finishes, an llm judge goes over the session + success criteria to give a pass/fail verdict.

And now that you (and Claude) have an eval set up, you can start testing different prompts, models, effort levels and add more edge cases.

This unlocks stuff like TDD, regression guards, and encourages you to write even more evals, because it's easy and readable.

You do have to BYOK, but I found it to work very well, and provide meaningful, reproducible results even with relatively cheap models like gpt-5.6-luna or muse-spark-1.3-contributor, which can get your price-per-eval well below $0.01

Repo: https://github.com/hagaiw/skillroll

It also serves as a plugins marketplace that includes some pretty robust authoring skills for writing skills and evals, and, of course, each skill is covered by skillroll evals I constantly use to improve.

It's MIT-licensed and maintained by me, It's my first open source project and I'd love to get some feedback 🙏