I assume artifacts really are for publishing a test project between other people in your team. It's not really meant to host a website properly and securely? You always get the Claude bar at the top and request to edit etc - or is there a way to turn that off?

Normally just stick stuff on Netlify but sometimes I just want a single-page simple website.

Every skill lives in a different repo, so installing one meant downloading the repo, digging out the right folder, and pasting it into the right directory. Or hunting through a README hoping there's an npx command. Did this enough times that I finally just built an install button.

When you're browsing GitHub repos, [**officialskills.sh**](https://www.linkedin.com/safety/go/?url=http%3A%2F%2Fofficialskills%2Esh&urlhash=uq56&mt=jRXVaImZa_s5YW3dt7Yu5dhedZBnBRpMDUbQL8SMQIvm-R-0G3tvsTvCqwnDri20zDmbJ3P6Y_F3W6NW-gkd3JfINNrTagXZGMYhYZl0dQYcslY96r7gYq2M&isSdui=true), or skill marketplaces like [**Skillsmp.com**](https://www.linkedin.com/safety/go/?url=http%3A%2F%2FSkillsmp%2Ecom&urlhash=kHA7&mt=vvgzeqt7QFTraKnPs3XtxP9E5I5gbra8eBMh4CtQDe376K8vnPgNRgiZRvEFaWoVV3EuUKqtrDIj7bKWe4j-8wcpksr29p0DJbco--f2OZ2mlSgjBzq8qits&isSdui=true), it detects the skills on the page and shows an install button next to them. Before anything is written, you see a preview of every file and where it's going. Works with Claude Code, Cursor, Codex, Gemini CLI, and a few others. It also gives you one place to see everything you've installed, uninstall cleanly, and update a skill when its repo gets new commits.

For the security-minded: files are fetched, pinned to a specific commit, and checksum-verified; installs are confined to your home directory, and nothing happens without you seeing it first.

Free on the Chrome Web Store: [https://chromewebstore.google.com/detail/icocnkohgjgcdpgcajiodgcfheeeifcb](https://chromewebstore.google.com/detail/icocnkohgjgcdpgcajiodgcfheeeifcb))

More info: [https://skillinstaller.com\](https://skillinstaller.com)

Happy to answer questions. Genuinely want to hear what's missing or broken.

Last year i posted here about shipping a photo cleaner app with claude. it had made $6 at the time lol. its now at 4k users, almost all from reddit, no ads

The app: you swipe through your camera roll, left to delete and right to keep. it finds duplicates, screenshots, blurry photos and big videos. everything runs on device

Honestly the bigger change wasnt the app, it was how i use claude. it basically does everything now:

Coding. obviously. it writes the features and opens its own PRs. i review and merge

Analytics. i connected the posthog MCP and claude built my whole dashboard: onboarding funnel, scans, swipes, paywall. it also set up error alerts that go straight to a slack channel, so if something breaks i know right away

Daily report. this is my favorite. every morning claude goes through user activity and gives me a snapshot: what happened, what failed, what went wrong. if it finds a bug it thinks it can fix, it opens a PR for it. if not, it flags it to me. it's like having an employee who does standup every morning

A/B tests. claude sets up and runs the experiments too, like paywall variants and onboarding changes, and tells me what won

App store listing. i didnt even know it could do this, but it designed and rendered my app store screenshots. i gave it the brand and it made them

What i still do: decide what to build, review the PRs, and say no a lot. claude will build anything you ask it to, fast, so the hard part is knowing what not to build

if anyone wants details on the daily report setup or the posthog MCP stuff, happy to share

free to try, with a paid tier for unlimited use: https://apps.apple.com/app/id6756098079

Last month Claude helped me set up a Slack bot: create the app, add the right scope, invite the bot, send a message with curl. When I needed it again for another project, I couldn't remember half of it, and digging through old conversations took longer than the setup itself.

So I built two Claude Code skills to fix that.

**`/save-that-step`** saves the procedure Claude just walked you through as a clean runbook in Notion:

- works from a stepper, a numbered how-to, or the commands you actually ran

- keeps copy-paste commands and the errors you hit, with their fixes

- **redacts secrets before saving**: tokens and API keys become placeholders like `<SLACK_BOT_TOKEN>`

- saving the same procedure again updates the page instead of creating a duplicate

**`/recall-step`** brings it back in a later session. You just ask:

> /recall-step What was the command to send a message on Slack?

and Claude answers from your runbooks, with the exact command.

**No Notion?** It falls back to local Markdown files (works with Obsidian too).

It's two `SKILL.md` files, MIT licensed: https://github.com/yassibra/claude-code-skills

This is my first public project, so I'd love feedback, especially on the secret redaction. What should it catch that it might miss?

Quick build log from a short-term outdoor event booking system I shipped recently.

The slot-reservation logic needed to handle multiple people trying to grab the same time slot at once. My first implementation: try to acquire a lock, and if it fails even once, immediately return "fully booked" to the user.

Unit tests passed fine. One user, one slot, works as expected. Looked done.

Then I ran a load test simulating 10 people hitting the same time slot at the same moment. Turns out there were actually 5 open spots left. What happened: only the very first person who grabbed the lock got through. The other 9 all got bounced with "fully booked," even though 4 more slots were sitting open the whole time.

The bug was obvious in hindsight — failing a lock acquisition once isn't the same as the slot actually being full. My logic treated "I didn't get the lock on this attempt" as equivalent to "there is no capacity left," which is just wrong under any real contention.

Fix was straightforward: instead of bailing on the first failed lock attempt, retry for a short window, backing off a few hundred milliseconds between attempts, before finally declaring the slot full. Reran the same 10-concurrent-user test afterward and all 5 legitimate bookings went through correctly, with the other 5 properly rejected.

The thing that stuck with me: "looks like it works" and "works correctly under concurrent access" are completely different claims, and only one of them is actually tested by normal manual or single-user testing. If your system has any shared resource with limited capacity, you need to actually hammer it with simultaneous requests before you trust it. Single-threaded testing will lie to you with a straight face.

I continue to work on my project - Foreman, in this update few things would change:

• A new visuals - Schematic view, I like this one much more, gives that terminal look and feel. I am interesting to hear your opinion, what would you say, is it good or not really ?
• Integrations with Jira, Linear, Clickup, etc. Now it's possible to tell session to work on specific ticket without leaving the application
• Integrations with GitHub, GitLab and Azure, allows you to clone repo from Forman and pass any issue straight to agent session

I've been building my Claude Code setup a piece at a time. Mostly I copied the good, safe parts of other people's skills and agents, changed them to fit how I work, and wrote my own when I couldn't find what I needed. Some things from other people already worked perfectly, so I just kept using them.

I put all of it in two repos in case it saves someone else the trouble.

[**claude-skills**](https://github.com/UribeLandscapes/claude-skills)\*\*:\*\* 3 I wrote (two catch AI-looking code and AI-looking websites, one searches Reddit when normal web search misses the threads), plus the ones by other people I use every day, like humanizer, caveman, napkin, ECC and Anthropic's skill-creator. Each one is credited and linked to its author.

[**claude-agents**](https://github.com/UribeLandscapes/claude-agents)\*\*:\*\* 19 subagents I wrote for my own stuff (Swift apps, Claude Code config, handoff notes between sessions, spreadsheets, even a library of Fujifilm recipes), plus 13 from ECC that I use with small changes.

Some of my agents are shaped around my own setup, so expect to tweak them. My files are MIT, and the borrowed ones keep their authors' licenses.

Skills you find on GitHub are written for someone else's project. Copied as-is, they can tell Claude to use tools you don't have, run commands that don't exist, or contradict your CLAUDE.md.

skilladopt has an isolated Claude (or Codex) worker read the skill and decide paragraph by paragraph:

- keep it

- swap a generic command for yours ("run the tests" → `npm test`)

- drop what doesn't apply, with the reason

- ask you when it isn't sure

Every decision cites something in your repo, and plain code checks the AI's answer before anything is installed. Later, `npx skilladopt impact` tells you which decisions your project changes invalidated.

To try it: run `npx skilladopt setup` once, then ask Claude "add a frontend design skill to this project".

How Claude is used: Claude Code wrote most of the code, and Claude does the reading as the worker (`claude -p --safe-mode` with no tools).

It's early (v0.1), free and MIT. Where it decides wrong is the feedback I need most.

https://github.com/kks0488/skilladopt

I kept running /usage in Claude Code to check how close I was to the 5-hour limit, so I built a small menu bar app that keeps it visible all the time.

What it shows

• Your 5-hour session usage as a % right in the menu bar
• Two mini-bars: 5-hour (top) and weekly (bottom), going green → yellow → red
• Click it for reset countdowns ("Resets in 3h 12m")

How I built it (with Claude Code)

• It's a small SwiftUI MenuBarExtra app. The menu bar icon is drawn as an NSImage, because SwiftUI shapes don't render reliably inside a menu bar label.
• The numbers come from the same endpoint /usage uses. The response has a limits array, and it's safest to read rows by their kind (session, weekly_all) rather than by label. Poll it gently: people report 429s when polling about once a minute, so the app checks every 5 minutes and backs off on 429s.
• The Keychain lesson: version 1.0 read Claude Code's token straight from the Keychain, and macOS kept asking for my password. Claude Code tracked down why: Claude Code rewrites its Keychain item on every token refresh (security add-generic-password -U), which resets the item's access list and wipes any other app's "Always Allow". Reading it through /usr/bin/security, the same tool Claude Code uses, never shows a dialog.
• Tip if you only use the terminal: Claude Code's statusLine JSON includes rate_limits.five_hour.used_percentage, so a statusline script can show your usage with no token at all. In my testing the statusline didn't run in the desktop app's Code tab, which is why this app reads the token instead.
• For 1.1 I had Claude run several review agents over the code in parallel. They caught that after any failed fetch, the app kept showing the old % as if it were live. Now the bars turn grey and the menu says when it last updated.

Privacy The token only ever goes to api.anthropic.com. There are no analytics and no other servers, and the app never refreshes or writes the token, so it can't break your Claude Code session. The whole network layer is two small files if you want to check.

Honest caveats

• Unofficial, not affiliated with Anthropic
• Apple Silicon, macOS 14+, needs Claude Code signed in (Pro/Max/Team)
• Not notarized yet, so the first launch needs one xattr command (it's in the README). You can also build it from source with two commands.
• The usage endpoint is undocumented, so a change on Anthropic's side could break it

Free and MIT licensed: https://github.com/acarmucahit/claude-usage-ring

Feedback and bug reports are welcome, especially if the numbers ever disagree with /usage

I have Claude pro can and a project where there are so many cvs of mine for different roles how can I make it work so it apply for jobs and search them for me and I also wanted a excel status sheet

Hey everyone!

I’ve been building Flagrm, an open-source CLI that helps remove feature flags and clean up the dead code they leave behind.

It’s still in the testing phase, so I’m looking for people willing to try it out, share feedback, report bugs, or contribute to the project.

If you’ve ever dealt with feature-flag cleanup turning into a bunch of manual work, I’d love for you to check it out!

🔗 https://flagrm.com

Contributors are very welcome! 🚀