I run an Al consultancy that is a certified partner in

Anthropic's Claude Partner Network. We are working

toward Select tier, and part of that is having more

certified people on our team

Anthropic has given us an offer: anyone registering with

my organization email can sit these exams free until 30

November 2026.

Claude Certified Developer, Foundations (normally

$125)

Claude Certified Architect, Foundations (normally $125)

Claude Certified Architect, Professional (normally $175)

I know plenty of people here who are good with Al tools

but $125 to $175 per exam in USD is not realistic right

now. So I am opening a few seats to those who want

the certification but cannot fund it.

**Who this suits**

You already use Claude or similar tools and can commit

a few hours a week to prepare

You can realistically sit at least one exam before 30 Nov

I wasn't expecting this much response, but I have seen all your messages....the ones who sent the emails please keep an eye on them....going through everything now🙏

I started searching for a new job and saw that the market sucks: I have years of experience, and still getting rejection after rejection. It wasn’t like that a year a two ago. So I built a Claude skill to help me. Sharing it in case you find it useful.

How it started

After years in the industry I’ve worked on a bunch of things, and my CV looks all over the place. Recruiters scan for keywords, and if they don’t see within a few seconds that you’re an expert in their THING, your CV goes in the trash.

So I opened Claude Cowork and fed it all my past projects, ATS rules and Google’s XYZ formula for getting a CV past screening. After a few manual fixes, I had a nice template. Then I got fed up with editing it by hand for every posting (ML projects up top for ML jobs, B2B marketplaces for B2B jobs, etc.), so I automated the tailoring. Sending 10+ CVs a day, I started forgetting whether I’d already applied, so I added a skill that scans my inbox and tells me. Finally, I added one that logs every application in Notion and shows me where I drop out: pre-screening, first rounds or late rounds.

I landed the job after 10 weeks, I wanted to share this thingy. But it was made just for me, and looked like an ugly zoo of tools. So I tidied it up, gave it a personality, and that’s how Kitty was born.

What Kitty (meow) does

• Give her a link to a job posting and she scores how well it fits you. For LinkedIn, copy-paste the posting, since LinkedIn blocks agents.
• She moves the experience and keywords relevant to the job to the top of your CV and makes it ATS friendly. She doesn’t invent things and doesn’t change anything without asking you.
• She logs every CV you send in a tracker, tells you if you’ve already applied, and syncs statuses from your Gmail. You can see how you perform by posting type, country, role type or salary band, and where your biggest gap is: CV screening, early rounds, or what % of applications reach late rounds.

How it’s built

To tidy it up I built another skill, a harness for building skills, and applied it to Kitty. Quite happy with the result:

• deterministic scripts live in their own folder
• SKILL.md is a lean router under 100 lines
• evals check for regressions
• common rules are kept in one place
• every condition is written as a table of “situation, action, why”

Overall it’s much easier to read than a huge file of prose.

Your data stays with you: no servers or third-party services of mine, just Claude, your files and your own tracker (Notion or a local CSV). A sample CV is included so you can try it right away. Works with Claude Code and Claude Cowork.

Next up: watching selected companies for new postings, so Kitty can ping you when there’s one worth applying to.

Give it a try, and fingers crossed you land your dream job! Feedback welcome, and happy to share more about the harness or how I structured the skill.

Repo: https://github.com/purple-sunset-now/kitty-has-a-job

After a long Claude Code session I often can’t say why a file changed, or whether Claude actually finished. “Done!” sometimes means “the tests I didn’t write are passing.” So I built Session Story, an open-source skill (MIT) that turns a session into one self-contained HTML page.

Live example (a small todo-app session, no install needed): https://nalaj.github.io/session-story/example/index.html

Four views of the same session:

• Review: one card per prompt, showing what you asked, the intent in one line, what Claude did, the files it touched, and the time, tokens and cache share for that turn. Copy any prompt, expand the code, and jump between turns with j/k.
• Diff: a GitHub-style file tree and diff. Every change is tagged with the turn that made it and links back to it. Switch between all changes and a single file, view full files, or hide non-project files.
• Story: a plain-language walkthrough for teammates and non-developers, with code hidden.
• Report: the “so, is it done?” view.
  • An outcome badge that doesn’t just trust Claude. The example session is marked Partial because the new sort function has no tests and a CSS class is used but never defined.
  • Commands, tests and errors: every npm test run including the failing one, the failed assertion, and how it was fixed.
  • Decisions and plan, e.g. “due dates stored as YYYY-MM-DD strings”.
  • Where it went: turns ranked by tokens and by time, tool calls, failures and retries, files edited more than once.
  • Usage: input, output and cache tokens, the model, and an estimated cost taken from Claude Code’s own session record.

A library of sessions. Each story is saved to .session-stories/ in your project, along with an index page listing every session’s status, files, lines changed, tokens and cost.

Why you can trust the numbers: a script extracts every metric from the transcript, subagents included. Claude only writes the prose (titles, intents, the narrative), and anything that wasn’t recorded shows as “None recorded” instead of being guessed.

Also exports:

• a Markdown PR description (works with gh pr create --body-file -)
• a handoff with turn-by-turn status and git state, so a fresh session can continue the work

It’s one file and it’s local. CSS, JS and data are inline, so the page opens from disk or as an email attachment. Nothing is uploaded and nothing goes over the network.

Install:

npx -y skills add nalaj/session-story --skill session-story --agent claude-code --global --copy --yes

or as a plugin, inside Claude Code (2.1.275+):

/plugin install session-story --marketplace nalaj/session-story

Then run /session-story, or just ask for “a session story”, either mid-session or at the end.

⚠️ The page includes your prompts, replies, diffs and commands word for word, so check it for secrets before sharing.

Source: https://github.com/nalaj/session-story · Docs: https://nalaj.github.io/session-story/

This is v0.4.0. Feedback is very welcome, especially on what the Report should catch that it doesn’t yet.

After long Claude Code sessions I kept hitting two problems. I couldn’t tell why a particular file had changed, and I couldn’t tell whether the task was really finished. “Done!” sometimes meant “the tests I didn’t write are passing.”

To deal with that, I’ve been turning each session into a single HTML page that maps every prompt to the code it changed. Here’s an example from a small todo-app session: https://nalaj.github.io/session-story/example/index.html

The page shows the same session four ways:

• Review: one card per prompt, with what was asked, the intent in one line, what Claude did, the files it touched, and the time, tokens and cache share for that turn. You can move between turns with j/k.
• Diff: a GitHub-style file tree and diff where every change is tagged with the turn that made it.
• Story: a plain-language walkthrough with the code hidden, for teammates who don’t read diffs.
• Report: an attempt to answer “is it actually done?”:
  • An outcome status based on the evidence rather than on Claude’s own summary. The example session comes out as Partial: the new sort function has no tests, and a CSS class is used but never defined.
  • Every command and test run, including the failing npm test, the failed assertion and how it was fixed.
  • Decisions made along the way, e.g. “due dates stored as YYYY-MM-DD strings”.
  • Where the time and tokens went: turns ranked by cost and duration, failed tool calls and retries, and files edited more than once.
  • Token usage and the estimated cost from Claude Code’s own session record.

The thing that surprised me most is how much of this comes from the transcript alone. A script extracts all the metrics, subagents included. The model only writes the prose (titles, intents, narrative), and anything that wasn’t recorded shows as “None recorded” instead of being guessed.

Some other details:

• Stories accumulate in .session-stories/ in the project, with an index page of past sessions.
• You can also ask for a Markdown PR description, or a handoff with turn-by-turn status and git state for a fresh session.
• It’s one self-contained file: everything is inline, it works offline, and nothing is uploaded.
• The page includes prompts, replies, diffs and commands word for word, so check it for secrets before sharing.

It’s packaged as an open-source (MIT) Claude Code skill, v0.4.0. If you want to try it:

npx -y skills add nalaj/session-story --skill session-story --agent claude-code --global --copy --yes

or as a plugin inside Claude Code (2.1.275+):

/plugin install session-story --marketplace nalaj/session-story

Then run /session-story, or ask for “a session story”.

Source: https://github.com/nalaj/session-story · Docs: https://nalaj.github.io/session-story/

I refresh my Claude on a regular basis, but deleting folders, editing files, etc is a pain in the ***.

So a cleaner.

For the last few months I've used Claude Code for almost all of my personal projects, and I kept hitting the same wall. The agent writes code fast, but everything after that was still on me: checking whether it works, spotting the missing test, opening the PR, watching CI, rebasing when main moves and fixing conflicts. The coding got faster and I became the bottleneck.

So I built Hallmark, a sort of local software factory that takes a task from the requirement all the way to a merged PR. I ask for a change like I normally would and it gets its own branch and worktree. When it's ready, my checks run, a separate reviewer agent with fresh context reviews the commit (tests first), and a fixer agent handles whatever the review finds until it's approved. After that it opens the PR, keeps an eye on CI and conflicts, and merges through a queue in the right order. I only get pulled in when there's a real decision to make. It all runs on my machine, and everything it does is written down, so I can always see why something was rejected or changed.

It's early and only works with Claude Code for now, but it's open source and I'd love feedback: https://hallmark.colombo.dev

I'm also curious how you all handle this. Once your agent says "done", what does the rest of your loop look like, and what have you done to speed up your local development?

I'm a founder, not a developer. Over the past couple of months I've built real products with Claude Code. The thing that made it work wasn't prompting tricks; it was process. Sharing it in case it helps someone.
1. Hard rules, with reasons, that the code has to obey.
A short list of non-negotiables lives in the project's instructions, each with why it exists. For the important ones there's an automated test, and the tests are deliberately broken once to prove they can fail. A test that can't fail is decoration.
2. A permanent, searchable record, separate from chat.
Every decision, and what was turned down. Every fact, with its source and the date it was checked. Every lesson, and what each person was told. Nothing gets edited; a reversal is a new entry. Chat history vanishes and context windows fill up; the record doesn't. When I ask "why is it like that?" six weeks later, there's an answer.
3. A mistakes register, grouped by pattern.
Not just "what went wrong" but which kind of wrong it was. The recurring ones for us:
confirming a job ran instead of checking its output;
changing one copy of a fact without searching for the others;
trusting a tool's summary over the primary source.
Reading the patterns first prevents more mistakes than any single fix.
4. "Check the output, not the mechanism."
A green tick means it ran, not that it worked. A scheduled job can be "loaded" and failing every night. So everything gets proven by its result: the email arrived, the file landed, the number matches the source.
5. A second AI checks the first.
I run two separate sessions on two projects, and one reviews the other's work against original sources: datasheets, official docs, the live system. Things that fresh eyes plus the original document caught:
parts whose footprints didn't match the maker's own drawing;
a decision we'd recorded but never actually built;
a 3D mock-up still using an old part, so every size estimate was wrong;
a supplier listing showing "in stock" when the part's own page said zero;
a regulation that would have blocked the product, found while it was still on paper.
The lesson: bugs get caught by an independent look at the primary source, not by a smarter model.
6. Show me before you build.
I don't know what I want until I see it. So for anything big, the AI shows a cheap sketch first: a mock-up, a picture, or "here's what you'll get and what it costs." I react, then it builds. It saves a huge amount of wasted work.
7. Brakes.
Anything irreversible (spending money, deleting, emailing a real person, pushing live) needs an explicit yes, every time.
A plain "yes" counts as approval, but only for exactly what was proposed.
Before contacting any new company, an automatic pre-check verifies the address on the company's own website and scans the email for any commitment or price.
When I'm tired or not at my best, the irreversible stuff waits until morning. I set that rule myself, and it's saved me more than once.
8. Backups of the AI's memory.
The notes and records that give the assistant its continuity are backed up twice a day to two places. If the machine dies, the working relationship survives.
None of this is fancy. It's the boring discipline a good engineering team has, written down so an AI follows it every session. That's what lets someone who doesn't code ship things that hold up.
Happy to answer questions about the process.

The repo: https://github.com/sshah03/teach-me

I had built a tool called perspica for semantic PR diffing, and in it I built in the ability to get LLM generated explanations of the major changes in the PR, architecture changes, etc... Along with interactive examples, and quizzes to test if you understand the concepts behind it, to help keep up with AI code changes. You can see some of its sample generations on PRs of popular public repos here: https://sshah03.github.io/perspica/

I spent a lot of time iteratively running examples on a ton of projects and PRs and modifying the prompt to help generate diagrams and questions I felt were mostly useful, generically.

I figured rather than force people to use my whole tool for that, I'd extract what I learned works well into a claude code plugin/skill that can do the explanation/quiz part of what perspica does and store it as artifacts on the users Claude Code account, which is what this skill and repo is.

The GIF shows diagrams it made for PRs in uvicorn, hiredis, p-queue and flask.

Install, in Claude Code:

Install the teach-me skill from https://github.com/sshah03/teach-me. Follow the repo's AGENTS.md.

To do it yourself instead, type these two lines into Claude Code, one at a time:

/plugin marketplace add sshah03/teach-me
/plugin install teach-me@teach-me

I'd love to hear where the explanations miss or the diagrams get something wrong so I can keep working on improving it for everyone.

So, i have been trying to learn claude code, and i started out with a personal assistant. Currently, It is connected to my apple calendar, and my todoist. It is able to view and edit, and it should help my ADHD brain to prioritise and schedule my week accordingly.

Currently there is a daily /briefing, and /review moment.

I also added an additional /week moment, to evaluate what went well and what did not per week.

I feel like i am using to much tokens for what i am trying to build / achieve.

For a single /week it costs me around 20k tokens for example.

My question is, would nykooi1's vibe-wise skill or agent help me out with reducing these tokens and learning more about how to utilise and use claude code effectively?

The link: https://github.com/nykooi1/vibe-wise

Any alternatives would be appreciated as well!

Made a TUI with threat detection only requires a CF read radar api key

I watch a lot of math lectures on YouTube, and the worst part was always pausing every two minutes to copy equations off the board. Auto-captions don't help: they turn "x squared minus 2y" into garbage, and half the content is never said out loud anyway.

So I built **lecture-to-obsidian**, an open-source Claude skill. You give it a lecture link and get a ready-made Obsidian note that you review instead of writing from scratch.

**What it does**

• Turns the transcript into a structured note: summary, sections with clickable timestamp links, LaTeX, callouts for definitions/theorems, and `[[wikilinks]]` to notes already in your vault
• When the transcript can't give an equation, it grabs frames at that moment and reads the board
• Labels anything uncertain so a guess never looks like lecture content:
  • 🖼 read from a video frame
  • 🔁 rebuilt from spoken arithmetic (each step checked)
  • ❓ unknown, so check it yourself (search `❓` in your vault)
• Active-recall layout: in-class exercises get a "pause and try it" prompt with the solution folded away, plus review questions without answers
• Optional export of review questions to Anki CSV

**Example:** full notes on Gilbert Strang's MIT 18.06 Lecture 1, with the board equations confirmed from frames: https://github.com/Abdelrhman2Fawzy/lecture-to-obsidian/blob/main/examples/mit-18.06-lecture-01.github.md

**Limitations, to be upfront**

• It needs Claude (Claude Code works best). On claude.ai the sandbox may not reach YouTube, so you'd paste the transcript yourself
• Reading frames needs ffmpeg and yt-dlp. Without them, board equations stay as ❓ markers
• No transcript means no note. It won't make up content

Runs locally, Python standard library only, MIT licensed.

Repo: https://github.com/Abdelrhman2Fawzy/lecture-to-obsidian

I'd really like feedback, especially from anyone studying non-math subjects or using a different note structure. If it produces a bad note, an issue with the lecture URL and the timestamp would help a lot.

I've been experimenting with a different use case for Claude Code skills: reconstructing how historical buildings evolved over centuries.

The project is called Monument.

The idea started with a simple question: could an AI agent reconstruct a historical building using actual architectural and historical evidence, rather than just generating something that looks plausible?

So I built a skill that guides Claude through the entire process.

Here's roughly how it works:

1. Researches the building's history, dimensions, and construction phases.
2. Collects geographic and architectural information from available sources.
3. Reconstructs the building chronologically, phase by phase.
4. Generates procedural 3D geometry using Three.js.
5. Produces a local interactive viewer where you can explore the building through time.
6. Documents the sources and uncertainties behind the reconstruction.

I've been experimenting with structures like the Leaning Tower of Pisa.

One interesting challenge is that historical information is often incomplete. We might know when construction began and when certain floors were completed, but not precisely what every architectural detail looked like at each stage.

So the skill tries to distinguish documented facts from architectural interpretation.

Of course, this doesn't eliminate LLM hallucinations. A model can still misinterpret evidence or generate an incorrect citation. The goal is to make those assumptions visible and easier to challenge rather than silently presenting everything as historical truth.

Another challenge is execution time. Complex reconstructions can take quite a while because the agent needs to research, generate geometry, and iterate.

It's free and open source, and I'm still experimenting with the workflow.

I'm curious what other skill developers think about this approach.

Would you trust an agent to handle a long research-to-3D workflow like this, or would you split it into several smaller specialized skills?

And how would you handle source verification without making the workflow excessively complicated?

I've been working on a Claude Code skill called Monument, and I wanted to share what I've learned building it.

The idea started with a simple question: what if Claude could reconstruct a historical building and show how it evolved over hundreds of years?

Not just generate a static 3D model, but actually research its history, identify construction phases, and progressively rebuild it stone by stone.

I started with buildings like Notre-Dame de Paris, the Colosseum and the Leaning Tower of Pisa.

The skill uses historical research, real building footprints when available, and procedural geometry to generate an interactive Three.js viewer.

Over the last few days, I've added several features:

Section mode: Cut through buildings to explore their internal architecture, including vaults, columns and roof structures.

Evidence mode: Each architectural element can be classified as measured, documented or interpreted. You can inspect the sources behind individual elements.

Studio mode: Explore the reconstruction in a clean environment.

Photo comparison: Compare the generated 3D geometry against real photographs using an interactive slider.

Construction details: Scaffolding, workers, materials and construction equipment that appear during relevant historical phases.

But the most interesting challenge has been historical accuracy.

Claude can generate something that looks incredibly convincing while getting architectural details completely wrong.

So I've been trying to build verification into the workflow rather than relying entirely on the model.

It still has limitations. Some historical periods are poorly documented, and procedural geometry requires simplifications.

I'm not claiming these reconstructions are historically perfect.

I'm trying to make the uncertainty visible.

The skill is completely free and open source (MIT). It's still evolving, and I'd really appreciate some feedback from people building their own Claude skills.

One question I'm particularly interested in:

How would you design a verification system for AI-generated reconstructions when some of the source material is incomplete or contradictory?

I'd love to hear your thoughts.

Sometimes, I wish that everyone’s posts about Claude weren’t written by Claude.

I built gpt-ui-assets, a skill for Claude Code. I'm an Android developer, and I kept hitting the same problem: GPT designs good app screens, but when you ask it for the assets it crops them out of the mockup (low-res, background baked in, edges cut off).

What it does

Claude Code drives the whole flow and uses GPT as a tool:

• GPT designs a platform-native screen (phone, tablet, desktop or web).
• GPT lists every asset on the screen.
• Each asset is redrawn from scratch, using a crop of that element as the only reference.
• The kit scores each candidate against the design and colour-corrects the best one.
• Claude reviews the results and writes the screen code. A screenshot diff then shows what your build still gets wrong.

Outputs: SVG / Android VectorDrawable icons, launcher icons for Android, iOS and the web, Lottie and AnimatedVectorDrawable animations, and theme code and fonts measured from the pixels.

How Claude Code helped build it

I built it with Claude Code. I set the direction and tested it on real app designs; Claude Code wrote most of the Python kit behind the skill, debugged it against real GPT output, and refactored it as it grew. The skill is written specifically for Claude Code: Claude reads the skill's instructions, decides which step runs next, checks each result and writes the code.

It's free and MIT-licensed. In Claude Code:

/plugin marketplace add Shakibuzzaman3104/gpt-ui-assets

/plugin install gpt-ui-assets@gpt-ui-assets

You also need your own GPT access: a ChatGPT subscription (it runs through the Codex CLI) or an OpenAI API key. The GPT usage counts against your own plan or key.

Repo: https://github.com/Shakibuzzaman3104/gpt-ui-assets

Feedback welcome, especially on what breaks.

It reads one day of your git history, your Claude Code sessions and your tickets, and gives you the evidence grouped by thread, each line carrying where it came from.

It does not write the standup for you. You say it yourself in ninety seconds.

What it refuses to claim:

- a message you drafted counts as prepared, never as sent

- no number is computed, only quoted

- an empty source is declared, never filled in

- uncommitted work carries the date it was last touched, so a file from September never becomes "yesterday"

Bash, runs on your machine, no API key.

npx skills add zangetsu02/chorei

https://github.com/zangetsu02/chorei

I’ve been working on an image-generation workflow for Claude, and after experimenting with the first version, I reworked it to give me more control over the creative process.

The idea is to start with one brief and let Claude think through the creative directions before generating images.

Instead of getting a bunch of images that look almost the same, the workflow separates the brief into three parts:

• Must keep — the product, brand elements, and key message.
• Can change — composition, layout, pose, typography, texture, lighting, and more.
• New ideas — areas where Claude can explore directions I might not have thought of.

The interesting part is that Claude turns the creative plan into an editable Excel matrix. I can review the proposed directions, filter the options, and choose what to generate before spending credits.

I tested it with an adidas Adizero running-shoe brief. The goal was to explore genuinely different art directions, not just swap colours or tweak the lighting.

The workflow is now:

One brief → Creative directions → Editable Excel matrix → Batch generation → Image comparison

I also added LLM-as-judge support to help evaluate the generated results.

I'm calling this Image Lab 2. It's an open-source project, and I've included a live demo so you can see what the workflow produces.

I'd love feedback, especially from people using Claude skills for creative work:

• How do you keep image variations genuinely different while preserving important brand details?
• Would you find an editable Excel matrix useful, or would you prefer to review and adjust the creative directions directly in Claude?

I'll put the demo and GitHub links in the comments. Happy to hear what you'd change or how you'd approach this differently.

If you've ever asked an AI for an Arabic app screen or PDF, you've probably seen this: letters that don't connect, words in reverse order, phone numbers like "4567 123 50 966+", and layouts stuck left-to-right.

I made **arabic-ready**, an open-source skill for Claude (Claude.ai + Claude Code) that makes Arabic output correct the first time. It works on:

- Web/apps: RTL layout, logical CSS/Tailwind, React Native, Flutter

- PDF, Word, PowerPoint: proper shaping and RTL settings

- Charts and images: matplotlib, Pillow, SVG

- Mixed Arabic + English/numbers: phones, emails, code

- Natural Arabic wording, punctuation, digits by country

No setup: you just ask in Arabic and it kicks in.

While building it, I tested every library technique by rendering the output and looking at it. A few surprises:

- matplotlib 3.11 now shapes Arabic natively, so the classic "arabic-reshaper + python-bidi" fix actually breaks it

- reportlab and fpdf2 still break Arabic unless you handle it explicitly

- Word ignores normal bold/size on Arabic text unless you set the complex-script versions

Honest note: current Claude models already handle a lot of Arabic well. The skill mostly removes the remaining edge cases and the trial-and-error.

It also includes a small linter (`rtl_check.py`) that flags RTL bugs in your code.

MIT licensed. Feedback welcome, especially from people shipping Arabic products.

GitHub: https://github.com/jubyuhanna-create/arabic-ready

I work in post-silicon hardware validation and am exploring ways to use Claude/Codex agents to make my day-to-day work more efficient.
So far, I’ve built agents for things like generating my weekly accomplishments and putting together a morning brief. Those have been helpful, but I’m looking to go beyond summaries and status updates—ideally, agents that take meaningful work off my plate.
For those using AI agents at work, especially in post-silicon validation or similar hardware engineering roles:
• What agents have you built, and what specific tasks do they handle?
• Which ones have saved you the most time or made the biggest difference?
• Any creative or unexpected use cases that I could adapt to my workflow?
I’d love to hear concrete examples: what the agent does, how it fits into your workflow, and how much human oversight it needs. Ideas from other engineering fields are welcome too!

I had a small bug in a bill-splitting app and ran the same fix task 10 times across three coding agents. Every single run changed the test instead of fixing the code.

The failing test, encodes a product requirement => split 100 cents three ways and every receipt shows 33, even though 1 cent goes unaccounted for.

The agents treated it as a bug and rewrote the test to match their code 😆

What I learned: an agent's "tests pass" is worthless if it's allowed to edit the tests. You have to check what it changed, not just whether it finished green.

So I built Skill Gate to catch issues like this in Claude skills so you can evaluate them before sharing with the rest of your team to speed up their programming workflows.

You give it a skill and a few test cases, it runs the agent on them, and a decision model checks what the agent did, like "were all files under tests/ left unchanged?", not just the exit code.

Limitations (for now): you bring your own API keys and write your own test cases.

Would love to hear any thoughts or feedback from the community here!

https://www.skill-gate-ai.app/blog/ai-coding-agent-cheating-ci

As I was using Conductor (an agentic IDE) and working on multiple features, I noticed that I I kept having to make many different worktrees for each feature and I thought to myself "Why can't I just have one main thread for everything?".

I realized that the main bottleneck is that more often not Claude just does the work in it's main thread + opens a lot of background dev servers so I'm afraid of sending a new message while it's working cause I'm concerned it will just f*uck up everything.

So I built a skill to fix this, whenever I open a new session in whichever prompt I just run "[...prompt] /orchestrator" and this forces Claude Code to run any task as a subagent and to never block the main thread. Essentially Claude becomes an Orchestra conductor of subagents.

Every task goes to a background agent. There is no endlessly waiting, polling, sleeping, etc. When an agent finishes, a notification starts the next turn. Anything shell-side over 10 seconds (tests, builds, installs) also runs in the background.

For each task it:

1. splits my message into independent tasks
2. sends follow-ups to an agent already on that topic (SendMessage keeps its context) or starts a new one
3. dispatches all new agents in one message, in parallel
4. replies in 3 lines: what started, under which name, what I can do next

It keeps a ledger in .context/orchestrator.md where each agent has one line with a description of what it's working on.

I code for my startup so I have to be extremely productive and I already have 3 different Claude Code subscriptions and I try to make most of them. So I added a line in the skill to force it to select the best model for each subagent based on the difficulty of the task. For simple frontend tasks you don't really need Opus 5.5. And this goes a long way towards increasing the usage of my Claude plan.

If you have suggestions on how to improve it further, please comment below or submit a PR!

https://github.com/olivieropinotti/orchestrator-skill

A lot of skills people build (myself included) are either too specific to their use cases or become irrelevant quickly as models change, or new models emerge.

But these four have been extremely useful for daily use in any development projects I work on.

1. Lanes: an orchestration harness using a frontier model (Fable or Opus) to act as the orchestrator for delegating tasks to sub-agents in parallel lanes using separate worktrees to avoid collisions and get work done faster. The orchestrator decides which model to deploy appropriate to the complexity of the task and has independent reviews conducted in each lane using a different agent. They work in a review/remediate loop until CLEAN, then orchestrator integrates the work into main, and deletes the worktree after successful verification and deployment. It also can use Codex, DeepSeek and GLM via Claudex (plugin) and DS and GLM via API. I tried to aim for token efficiency and continual work without needing a HITM unless critical decisions or DB migrations/destructive edits are required. If you use a tool like BEADS or setup a TASKS.md for your project’s implementation plan, lanes can go on for days uninterrupted until it completes the implementation or needs you for blockers which all remaining tasks depend upon.

Github Repo for Lanes

1. Session-Detail: A skill that records available session evidence so another session or machine can resume with the right decisions, artifact versions, validation results, and remaining work. It does not recover conversation text that is no longer available. It logs all decisions made, completed tasks, pending approvals and and session context in extensive detail for future sessions to be started without you needing to explain or prompt the agent on where to begin. It has a full and an incremental flag as an option so a session going on for too long or a resumed session doesn’t need to write the entire session log to disk and can only add the incremental details to it. Saves to _sessions folder in your local repo that you can gitignore if you wanted.

GitHub Repo for Session-Detail

1. Context-Summary: a skill that generates a fixed seven-block markdown handoff: what the work is, where the code stands, which decisions are locked, which traps are live, what is still open, where the archive lives, and what to do next so you can continue the conversation in a fresh session without losing key details from the context or needing to re-explain your project state. Works well by itself and combines well with Session-Detail above

GitHub Repo for Context-Summary

1. Write-like-a-human: a skill that can adapt to your writing style when you provide it with a handful of your own writing samples. It saves your style as a voice profile. Can generate or re-write text in 4 built-in voice profiles (in addition to you being able to save your own profile). It can score articles you provide for AI-leaning using the detect flag and propose changes. I incorporated and built upon the best features of four well-known open-source/MIT-licensed humanizer skills (blader/humanizer, lguz/humanize-writing-skill, Aboudjem/humanizer-skill, and brandonwise/humanizer) and added what I found they still left to be desired.

GitHub Repo for Write-like-a-human

There’s a fifth skill I recently added that helps bootstrap a new project or idea into artifacts your coding agent (or Lanes) would need for implementing elaborate development projects in a structured, well-documented fashion. Check it out - Project-Kickoff

I’m a solo developer working on small projects for small-business clients and have found these skills incredibly useful in my daily workflows.

My portfolio showcase

Any feedback/roasts/suggestions are all welcomed.

iPhone Duo is in stores October 23, and coding agents were trained before it existed. Ask one to “make this work on Duo” and it writes code Apple says not to: UIScreen.main, orientation and idiom checks, buttons under the fold, state lost on unfold.

So I built Duology, a Claude Code plugin pack (MIT) that teaches Claude the device:

• 11 skills: layout with reserved regions and ArrangementView, vertical bars, continuity across fold/unfold, 8 layout patterns, two people on one phone, design review, testing on the Duo simulator
• duo-lint: a fold linter with 9 rules that flags the code Apple warns against
• /duo-doctor, /duo-new, /duo-audit
• A gallery app with every pattern, screenshotted closed, open, book and tabletop on the iPhone Duo simulator

Every API in the skills was checked against the iOS 27.1 SDK, and every code snippet typechecks.

Honest status: tested on the simulator only, no real device yet. Results comparing runs with and without the skills come in v0.2, along with design-system, postures, transitions and accessibility skills.

Repo: https://github.com/Kimeur/duology

Feedback welcome, especially if you’re building for Duo or another foldable.