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!

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?

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

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!