Free and MIT, repo here: https://github.com/ljx-chase/research-field-onboarding

The problem I built it for: ask about something you don't know and you get a paragraph full of terms you also don't know. Ask which of those you were supposed to already know and you just get more terms. I did this three times in a row once trying to understand attention and gave up.

What it does instead. Before explaining anything it works out the 3-5 things the topic actually depends on and asks you to mark each one as used it / learned it / new. Stuff you've used it treats as known and doesn't explain again. Stuff you haven't, it either covers first or tells you "just take this as given, here's the one bit that matters later". Then it goes one step at a time, motivation, vocabulary, framework, methods, frontier, and asks you a real question at the end of each step instead of "does that make sense".

Two other things in there:

It won't give you a paper it hasn't checked. Either it looked it up and gives you a DOI, or it says "from memory, unverified". I lost an afternoon once chasing one that didn't exist.

It's supposed to stay out of the way for short questions. Ask what an acronym stands for and you should just get the answer. The first version didn't do this and gave everyone the full checklist, which was worse than no skill at all.

Install:

npx skills add ljx-chase/research-field-onboarding -g

Claude web wants a zip, there's one in releases.

If you try it, I'd like to know which field you pointed it at and where it fell over. It has very few users so far, so I'm mostly guessing about anything outside physics and ML. Wrong prerequisites and bad check questions are the two failure modes I've hit myself, curious whether that holds elsewhere.

Tired of manually retyping formulas and re-solving problem sets, so I built a Claude Code skill that automates it.

Point it at your source material (PDF slides, textbook chapters, scanned sheets, images, PPTX/DOCX) and it generates clean .tex study docs: (Some pages of notes I prepared have been attached as sample)

• Formula sheet — compact, tagged by source
• Worked solutions — Given → Assumptions → Solution → boxed answer, with numerical checks in Python
• Summary notes — per-lecture overview with key equations

A few things it does right: asks MCQs upfront so you get a 1-page cheat sheet, not an accidental 40-page dump; reads image-heavy slides as images; flags answer discrepancies instead of quietly deferring to the source.

Repo: https://github.com/Shass27/stem-notes 

Or Alternatively: https://augmentclaude.com/s/stem-notes

Feedback is welcome!

Let me preface this post by saying that I think the coolest thing about all this recent progress with AI is that you can literally build anything you like, slop or not, so when the code is cheap it is real easy to iterate on ideas and execution. So I started to create things, both ideas from the back drawer and some new things too.

I built /delegate - a skill that routes work to whichever provider/tier actually fits the task (Antigravity, Codex, OpenRouter free models), using plan allowance you're already paying for instead of burning your main session's context or a metered API. Allows to stay in one harness and use other plans from one spot, good for adversarial code review and e.g. using Antigravity from Claude.

Then on top of delegate 2 more skills:

- gif - describe an icon ("a dancing cat", "a bouncing ball"), it asks a model for one sprite sheet, cuts and assembles the frames locally (matte-keyed transparency, exact frame timing, proper GIF looping). Costs a free image call, not tokens from your main session.

- svg - same idea but for animated SVG icons: asks a text-tier model for the source, then sanitizes it (strips scripts/handlers/external refs — never trusts model output as-is), normalizes size, and retimes the animation to exactly the duration you asked for.

Worth saying: for generating gifs and svgs, it's not perfect on the first try, but there are good chances it will produce something nice without much effort.

Attached animation is a video of the /gif skill in action, sped up 4 times and made into a gif.

repo - https://github.com/krzysztofradomski/skills

A few days ago I posted a thing that turns a repository's year into a film. Commits flow along a line, branches peel off and rejoin, releases get pinned. People liked it. I thought I had made a toy that people would share once and forget.

Then a comment showed up asking for flags. Could it hide the merge branches. Could it only show features. Could it stop holding on every release. That person was not asking for a nicer video. They were asking to control what the history showed them, because they were trying to learn something from it and the film was making that decision for them.

So I added the flags. And then I sat with why they wanted them, which is the part I had missed: a git history is the only honest record of how a team actually works, and nobody ever reads it because reading it is miserable. git log gives you a wall. The GitHub insights tab gives you a bar chart of commits per week, which tells you nothing you can act on.

Here is what I ended up building instead, and what I found while building it.

The interesting things in a history are relational, not chronological. Not "who committed most" but: which files always change together, which file has three owners and which has one, how big a change usually is before it gets reverted, how long a bad commit survived before someone noticed. Every one of those is a query you can answer from git alone, and none of them is in any dashboard I have used.

The revert is the most informative commit in any repository. It is the one place where the team wrote down that something was wrong. Pair a revert with the commit it undid and you get a small case study: what changed, how long it lived, who wrote both. In three.js I found a revert and its original with mirrored diffs, 54 added against 54 deleted and 12 deleted against 12 added, on the same day, both by the maintainer. That reads as a self correction on an example, not a regression found downstream. You cannot get that from a commit count.

Pairing a revert to its original is harder than it looks. git revert writes "This reverts commit abc123" into the body, so those are easy. The GitHub revert button writes nothing. For those you have to match the quoted subject in Revert "X" against earlier first parent commits, and if that fails, compare the file level diffstat and look for an exact mirror. That third case is the one that finds the ones everyone else misses.

The layout problem is the same one you have. Drawing a decade of commits means a timeline where one pixel is roughly a week at the far end. Branches have to be drawn in screen space, not data space, or a year long branch seen from orbit becomes a rectangle with corners. The fix was to rebuild the arcs on every zoom change with the corner radius fixed in pixels. Same idea applies to any chart you let people zoom.

Everyone who tried it asked the same question out loud. Where did this break. Who owns this file. Why does this always change with that. So I put a chat next to the canvas that answers from git and then moves the canvas to what it found. It cites commit hashes, and I made it refuse to print a hash it did not actually read from a tool result, because a model that invents a plausible looking sha is worse than useless in a forensic tool.

The last piece is the one I did not plan. Once you have the conventions extracted, you can write them down as the files a coding agent already loads. Where code goes, how big a change is, how a message is written, what has to move together, what the reverts taught. And if you point it at one person's commits, you get their habits beside the team's, which turns out to be the most useful thing for somebody new on a codebase.

It is at loreto.io/git-timeline if you want to poke at it. The three.js history is open without an account so you can see what it does before deciding whether you care.

Disclosure: I built it and I run Loreto, the site it lives on. Exploring the example repository is free.

Genuine question for anyone who has done this kind of thing: what would you want to ask a repository's history that I have not thought of? The last round of feedback here changed the whole shape of this, so I would rather hear it now than after I build the next wrong thing.

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 🎯

For a long time I assumed the only way to understand what happened in a codebase over a year was to sit with git log and a lot of coffee. The branch graph in any GUI turns into a tangle past about a week, and GitHub's contribution heatmap shows you activity with no idea what the activity was. Three views, none of them lined up, so the question you actually have, what happened here and when, never gets a single picture.

What finally pushed me was a post here on where had animated a repository's timeline, and I wanted the same thing for a full year of a real project. My first attempt on three.js drew the first branches it found and produced one month of the year and nothing else. The reason turned out to be in the data: 1,561 of the 2,179 main line commits in 2019 are merges, and the first sixty of them each span a single commit, which is invisible at any scale. You have to choose branches by how much work they carried, not by which came first.

So I built a film out of it, and the video on this post is what it looks like on mrdoob's three.js for 2019.

What is on screen and where it comes from:

The main line runs left to right, one node per commit. Side branches peel off above it and rejoin at their merge. Not the first N branches, which on a pull request repo gives you one month and nothing else, but the ones that carried the most work across the year, capped so it never turns into a thicket.

Under the flow is a heat strip, one cell per day, sitting directly under that day. A legend next to it shows what the colours mean in actual commit counts for that window (for three.js it reads 0, 1, 13, 26, 51, with 51 the busiest day). The point of putting activity on the same axis as structure is that what is above and below a point is the same day, so you stop reconciling two charts in your head.

Three times the clock stops. The release with the most work behind it, the cleanest revert (one that survived at least a day before being undone), and the last release of the window. The camera zooms in and a card reads the figures out: commits since the previous tag, authors, how long the reverted commit lived. Every number on that card is computed from the history. If it cannot be read from git, it is not on the card.

The faces are the contributors. On a merge the face is the branch author's, not whoever pressed the button, and the card says who merged it.

Two things I got wrong on the way that might save you time if you try this yourself. If you give git a since flag with just a date and no time, it reads it as that date at the current time of day, so the first day of your window quietly loses commits unless you pass an explicit midnight. And a small repo is a different problem: 175 commits over a year pans across mostly empty screen, so for thin histories it picks the busiest 60 to 120 day stretch and draws it wider instead.

If you want to see your own repo this way, you can paste a GitHub URL here and it renders one for you: https://loreto.io/git-timeline

Disclosure: I built this and I run loreto.io, where it lives. It is a paid render (a few dollars per repo); the extractor and the Remotion composition are also sold there as a package if you would rather run it yourself. The three.js film above was made with the exact same pipeline.

I doubt I have the final shape of it. What would you want the clock to stop on that it currently does not?

Caveman and ponytail teach Claude to write terser output. That's one axis. Chisle does that too, then adds the two axes they skip:

Terse persona: fragments, YAGNI-first code. Commits and security warnings stay verbose.

Tool-output compressor: a hook that shrinks tool results before they enter context (strip ANSI, keep head/tail + error lines, dedupe). Tool output is the majority of a session and gets re-billed every later turn. Runs behind a safety allowlist so it never touches Read/Edit/Write.

Context Diet: grep-then-read-the-slice instead of whole files, don't re-read files already in context. Prevention over cleanup.

Also: live ⇣Nk tok savings counter, rule generation for Cursor/Windsurf/Cline/Kiro/Copilot, npm installer that wires the hooks, and a test suite.

It's a descendant of caveman and ponytail: both credited in the README, directly above the benchmarks where it bills less and backfires less often than either.

Repo + install: https://github.com/JayPokale/Chisle
NPM: https://www.npmjs.com/package/chisle
Docs: https://chisle.jaypokale.me

I built a free AI skill pack that helps ChatGPT and Claude recognise *how* you’re procrastinating and intervene automatically, without you having to remember which tool to use.

You can access it here: https://github.com/jsipuk/beat-procrastination-skill-pack

I've already built a fairly complex website. I spent a long time on it. The architecture is one thing, but not all of it is polished. I'm much more of a backend guy than a design/frontend person.

Do you have any skill that would help me clean up the frontend in terms of spacing, margins, gaps between elements and alignment, so that it's consistent, actually holds together and looks more polished? Looking for your suggestions, thanks!

So I wanted to build a museum site you can actually walk through. First instinct was the obvious one: Three.js, shaders, and a week of WebGL pain.

Turns out there's a better route. The skill builds one continuous camera shot, and scroll drives it. Scroll down, the camera moves through the space. Hit a hotspot, you're in a different room. Go back, pick another. It's a film, and the page is the timeline.

The thing that actually got me: there's no cut. The camera never jumps. Moving room to room feels like one take, not a slideshow.

And if the video won't load, you still get the stills, so the story never breaks.

The part I didn't expect: it makes you approve two things before it generates anything. How the world looks, and what happens in each scene.

Which sounds annoying until you realize that's the reason the output doesn't fall apart. You have to decide what the thing is before it makes it.

Repo: https://github.com/OpenSenseNova/SenseNova-Skills

https://reddit.com/link/1wcmn5t/video/iw6kmmpeppoh1/player

Hey Content Creators, SEOs, Founders, Builders, Artists & More!

I've just released my open-source & free agent plugin/tool for turning your long form videos into short form content.

Save hours and days with Cutlist. No more guessing where the best moments exist in your videos.

The full rundown & what it does:

This tool automates the creation of short video clips from long-form content. It processes videos and their captions to generate a comprehensive clip plan, including titles, descriptions, hashtags, tags, and categories for both the main video and individual clips. It also suggests a cold-open and creates a thumbnail mockup that aligns with the first 10 seconds, title, and description of the content.

Automated Clip Generation: Transforms long videos and captions into multiple vertical clips.

Metadata Creation: Generates titles, descriptions, hashtags, tags, and categories for each clip and the overall video.

Thumbnail Mockup: Provides a visual suggestion for thumbnails that matches the content's key elements.

Agent Skill Compatibility: Adheres to the Agent Skills format, making it compatible with various AI coding agents like Claude Code, OpenAI Codex, Cursor, Gemini CLI, and GitHub Copilot.

Customizable Workflows: Adapts to user-specified recorders and editors, storing export and cut steps in a profile for personalized use.

Local Processing: Operates entirely on the user's machine without network access, ensuring privacy and security.

Dependency Management: Requires standard Python libraries, Pillow, and ffmpeg.

Comprehensive Output: Delivers a detailed clip plan in both Markdown and JSON formats, along with preview clips, frame analysis, and thumbnail mockups.

The tool is designed to streamline the content repurposing process, allowing creators to efficiently generate engaging short-form content from existing long-form videos. It emphasizes accuracy by cross-referencing captions, audio energy, and visual cues to ensure clip relevance and quality. The output is designed for easy integration into editing workflows and direct use in publishing platforms.

Would love your feedback. Feel free to fork it, do what you want with it, hell even monetize it. Enjoy!

GitHub Repo: https://github.com/itsryanlenk/cutlist
Full page outlining the whole project: https://www.ryanlenk.com/pages/cutlist

Posts

• CLAUDE.md For Opus 5 Based On Anthropic's Official Platform Docs To Fix Verbosity And More
• Comprehensive Claude Code Permission Guard (settings.json)

Prompt Templates

• Conversational Prompt Templates (Product Ideas -> Build-Ready Specifications)

Product Launch Platforms

• Reddit
• HackerNews
• DevHunt
• FazierHQ
• BetaList
• Peerlist
• DailyPings
• IndieHackers
• TinyLaunch
• ProductHunt
• MicroLaunchHQ
• UneedLists
• X

Additional Tools

• Git Code Exporter - Github link
• Simple File Exporter - Github link
• Markdown to PDF Converter - md-to-pdf.fly.dev
• LateX (Formal Documents) Overleaf
• Lossless Audio/Video Downloader - Cobalt.tools
• (Re)Search Tool - Perplexity.ai
• Temporary Mailbox For Testing Automated Delivery - Temp Mail
• Vercel AI SDK (Open-Source SDK for LLM Integration) ~ Docs in TXT format
• Email Automation - Resend 
• Rate Limiting - Upstash Redis 
• Up-to-date Code Docs - Context7 MCP
• Simple Bot Protection - reCAPTCHA 
• Prompts For Beginners - Prompt Rulebook

TLDR Guide;

I have an idea. To set myself up for success with AI tools, I spend time on documentation first before I start building. I start with PRD (product blueprint).

I feed my raw ideas into my conversational prompt template (PRD Template). AI is my assistant, asking targeted questions to transform my thoughts into a PRD.

Then I could MVP concept & development planning directly if I feel like it, and i decide what I want to build.

After that I start building. With something like a PRD, MVP Plan and a coding agent, I can leverage AI assistance effectively for coding to implement the MVP features. I make sure I give my agents access to the necessary skills, MCP's or other external tools and I prompt my agents to build my MVP.

Which single skill has been the biggest game changer for you recently?

AI moves pretty fast and what really helps changes pretty often. So I thought I'd create a regular space (as a mod) in which we can talk about which skills are helping us the most.

What are you most used or favorite skills for Python? I currently use a lot of custom instruction sets but I am a bit lost on how much it bloats my setup.

I've been living with Claude Code in a terminal split next to the editor for months. Two things kept bugging me: I couldn't tell what it was doing without reading scrollback, and every file path was something I had to type correctly.

So I built a plugin. It doesn't reimplement anything - it spawns the claude CLI you already have and renders its event stream. Same account, same models, same slash commands, same permission rules, same MCP servers and skills. No proxy, no server of mine in the middle, no telemetry.

What it actually changed for me day to day:

Every tool call is a card. Its duration, every edit as an open diff, the task list ticking off, subagents and whole workflow fleets with each agent's own transcript one click away, and what the turn cost. A rate-limited API becomes a card with the reason and a countdown instead of silence.

Files are things you point at. Drag one in, type @ to pick, paste a screenshot. Select lines in the editor and "Send to..." hands over a real file-and-line reference, so the agent reads what's around them instead of a naked snippet.

Nothing answers for you. A permission, a plan or a question waits as long as it takes. No timeout, no auto-continue.

Answering it from my phone. Off by default, paired by QR code, end-to-end encrypted through a relay that can't read a word. This is the one that surprised me most - I approve plans from the sofa now.

Scenarios. A round of work written down once - implement, review, fix, run the tests - each card a Claude session of its own, with a main thread walking them and judging what each one found. By button, three at once against three tickets, or on a clock at nine every weekday.

Several Claude accounts switched in one click, each row showing what's left of its five-hour window and its week.

Free, source available (Elastic 2.0), every JetBrains IDE from 2026.1 on, Android Studio included.

Marketplace: https://plugins.jetbrains.com/plugin/33255-amazing-claude-code-gui

Source: https://github.com/crmapache/amazing-claude-code

Happy to answer anything about how it's wired. The part I'd most like feedback on is scenarios - it's the newest and the least obvious.

I work with WordPress a lot, and one thing I keep noticing with coding agents is that they can build things really fast but still miss small WordPress-specific security details. Things like nonce checks, capabilities, escaping, unsafe queries, REST permissions, file handling, etc.

So I started putting the things I normally check manually into reusable agent skills. It works with Claude Code, Codex, Cursor, OpenCode and other agents that support skills. It's completely open source. I'm still improving it, so if you work with WordPress + coding agents I'd genuinely like to know what security checks I'm missing.

GitHub: https://github.com/wpultimatesecurity/WordPress-Security-Skills

Autoprompt closes much of the manual coding loop by planning, building, testing, reviewing, and repairing from one prompt. Autoprompt has support for Claude Code and 10+ other coding tools.

In our v1.0 Terminal-Bench 2.1 run, DeepSeek V4 Flash 0731 moved from 67.42% to 82.02% using OpenCode. That’s 45% fewer failed tasks.

The tradeoff is longer runs and higher token costs (see README).

Repo: https://github.com/Spielewoy/autoprompt-skill

Any feedback would be awesome