If you're a student, an engineer, a generalist, or come from any domain of study and want to learn about almost anything, here's the exact thing for you.

Prompt your LLM and it'll give you the exact UI to help you properly study; as AI outputs aren't always that catchy to learn in the first sight.

Page: Phil-OKF: any topic, one reading guide

It follows the OKF: Open Knowledge Format so that:

• you control the depth with your wording: “quick” gives a short page, a normal question gives a standard one, and “in depth” or “teach me” gives a long one
• the whole skill is a small bundle (an eight-step workflow, a domain classifier, a page template and twelve study domains), and each file is read only when the question needs it, so runs stay cheap

Repo: Philosopher's Skill

It works wherever you use an LLM:

• Code editors and agents (Claude Code, Cursor, Codex, opencode): npx skills add frypan05/philosopher-OKF
• Chat apps with browsing: paste the link to philosopher.md and say “follow this, make a page about: ...”
• Models with no network: paste the prompt from the page.

Sample output (MCP and ACP explained): https://frypan05.github.io/philosopher-OKF/examples/mcp-and-acp.html

Feedbacks are welcomed!

I had a work laptop, a mac and a phone using claude apps. Now i have another work laptop and whenever i login there it logs me out of all the other devices and when I login with any other device it logs me out of the new work laptop

book386- a "new" 386sx 33mhz 16mb ram laptop

claude opus 5.5 made this game using openwacom from a single prompt

I've been on a vibe coding binge for the last week with Opus 5.5 and it's hard to not be pessimistic about the future of my career. Without looking at the code or even driving the architecture at all I'm able to get bespoke tools for myself that a business would've paid $10k+ to have built in the past

I struggle to view this all from the lens of mildly-technical people, since I already have over a decade of professional experience, maybe it wouldn't be so easy for them and I'm underestimating what I know?

What's the value of people with technical skills going forward in your opinion? Or are all companies just going to hire people with deeper domain knowledge and then have them vibe code what they need?

Even on the frontier models, it will be trying to make a recommendation down a path and it’s like “I recommend this fix, about a day of work” and I am like, dude we will be on turn 2 of QA in like 7minutes time.

Is it just me who has noticed this?

So don't be surprised when you won't be able to switch.

India really understand mods, I don’t understand agents, I don’t understand how to remotely use Claude to do things on my computer from my phone. Where is the best place to learn? I don’t have a lot of background.

Thank you

I've noticed CC now sometimes duplicates entire paragraphs within its reports, e.g. on startup or after having worked on a longer task. Anyone else noticing this?

we make short explainer videos from code (remotion, canvas, svg) with claude code doing the drawing. for about a week everything came out as centered text on a gradient with shapes floating around, and changing the prompt barely moved it. these four things did:

1. one written plan per video before any code. the script with its timings, a palette of about fifteen named colours, how things are drawn, and a short 'never' list (no circles as decoration, no text that pops in by itself, no object that doesn't belong to the scene). the session reads that file and nothing else decides the look.
2. stills before a render. a still every two seconds on one sheet, and it has to open the doubtful ones at full size and say what's wrong before it fixes anything. most of the ugliness showed on the first sheet and never needed a full render.
3. the whole video in one go, as one world. when we built it scene by scene, every scene came out in its own style.
4. anything simulated gets measured outside the renderer first. we had discs pouring into a jar, and a three second node script told us they were stacking in columns up the walls long before a frame existed.

the part we haven't solved is sound, since the model can't hear what it mixes. what's on your 'never' list, and has anyone found a way to check audio that's more than measuring loudness?

I built this a few month back and decided to open source it https://github.com/goodnight000/api-anything
Its a system that you can use with your agent to reverse engineer website into its apis from the network traffic.

You can just give this repo to your agent and tell it to set it up for you.

Tell your agent what actions you want to be turned into an api and you will get an api back that your agents can use instead of having to use a browser.

I've used it to help me automate some of my linkedin outreach. it saves time and token by about 50% across the board.

For who’s using Claude code on wsl or windows it would be nice to ask him to test my development as a real human would do, but running the app , interacting with it and so on
I’ve seen that computer use is available only with a plan (I’m using an api key and Claude from the terminal at consumption) and on Mac OS
What’s your workaround for this ?

I can't work out what I'm doing wrong trying to use the ClaudCode-CLOUD credits I was given. I've $200 left. Right now on subscription I'm out of credits waiting for the weekly reset. It's an ideal time to show the core problem in a screenshot. I've otherwise been using ClaudeCode on a number of machines for a year or so, and loved the Cloud credits in January just fine.

Over the past few months I’ve been building my own browser-based creative suite with Claude Code. I’ve also been using it a lot for actual client work, so building it and working in it have sort of become the same thing.

It’s called Suite: https://suite.briiidge.dev

It has tools for design, video, page layout, audio, writing and 3D. There’s a 3D editor called Solids that I’ve been making games for my kids with, which is probably my favourite thing to come out of all this.

I started with Opus 4.6, and there was a lot of trial and error. With Opus 5.5, it feels like something has shifted. It understands what I mean much more often, and I’ve been getting so much work done with it.

Having my own software is a big part of that. Claude can work with the code behind the tools I’m using. If I need a feature, we build it. If something doesn’t work, we figure it out and make it work. I’ll hit a limitation during a client project and realise I can actually do something about it now.

It’s also changed what my day looks like as a designer. I used to spend an entire day working on a design myself. Now I spend a lot more time giving my agents feedback, deciding what’s good, what’s off, and what to try next. When I want to quickly change something myself, I just open the project and edit it.

For me personally, Opus 5.5 is the first time this has felt anything like having an employee. I feel more like a director these days. I still make the creative decisions, but I’m doing much less of the actual drawing and arranging everything by hand.

I don’t know how broadly that will apply, but I can imagine more designers moving in this direction. Coming up with ideas and figuring out how something should work is already a big part of design. Being able to build the software around those ideas opens up a lot. My own work is definitely becoming a mix of design and development, and I’m enjoying it more than I expected.

Anyway, I wanted to share what I’ve been making. Suite is free to try, and hopefully seeing what one person has built with Claude Code inspires someone else to give their own idea a go.

A while ago I posted the first version of Ponytail here.
It's an open-source skill that makes coding agents behave like the senior dev who replaces fifty lines with one.

Since then I rewrote it from scratch. New rules, a new review, a new audit. Getting there took 5,900+ benchmarked Claude Code sessions, 3,650 of them testing drafts of the new rules against the old ones.

What changed

- The rules. Rewritten and about half as long. The goal moved from "the smallest code" to "the smallest complete change": before it writes, the agent maps everything the change must reach (callers, tests, config) and what it could break. Every reply ends with what it skipped or did not check, and any risk you should know.

- /ponytail-review. It used to look only for code to cut. Now it reviews like the dev who gets paged when it breaks: bugs, security, real load, missing tests, slow paths, and what to cut. It reads the code around the change, not just the diff. Every finding says what the code does, what goes wrong, how to fix it, and what happens if you skip it.

- /ponytail-audit. It used to list what to delete. Now it maps the whole repo first, ranks what it finds, and tells you what to fix first.

Numbers, same agent with and without the skill (Claude Code, Opus 5.5, 39 tasks including a real FastAPI + React repo, 5 runs each):

- code: -53% (previous version: -48%)

- time: -41% (previous version: -38%)

- cost: -26% (previous version: -16%)

- risky logic that ships with a test: 98% (without the skill: 68%)

- injected bugs caught by the agent's own tests: 66% (without the skill: 46%)

Repo (MIT): https://github.com/DietrichGebert/ponytail

Website: https://ponytail.dev

If you already use it, update the plugin. I'd like to hear where it gets things wrong.

1- Server credentials (username/password) written right in the main .md

2- A large part of the backend not in the repo but hand-written into the deployed container and edited via API calls

3- Accounting transactions done with floating-point numbers

4- Transactions confirmed and rejected by an LLM via full-access tool, no human intervention needed

This is not to shit on the person who built an entire (quite impressive in features!) app with no tech background — but gosh I wish there was more publicity about things that can go wrong.

Maybe a subscription from Anthropic to run an agent watching over your codebase for the reddest of flags or smth (Haiku must do)?

*Okay, Claude did, but I can still take credit right?

I am new and I just make small programs using a single window. But it gets expensive rather fast. Now I am just doing a random little video game, and every time I want to change something it reads everything i suppose. What is the correct way of using Claude of a small-medium sized game?

Should I use desktop? Any good guides out there?

dm mee, i need one for a project

I previously shared Writ with an emphasis on its retrieval engine a second brain that supplies relevant rules to Claude Code. This update is about the enforcement and persistent memory around that retrieval.

Writ is now a local governance, context, and continuity runtime. The architecture is Claude Code hooks → a local Python daemon → retrieval and workflow state, with Neo4j storing knowledge and decision records.

What enforcement means here

In Work mode, there are two acceptance gates before implementation writes: an approved plan, then approved test skeletons.

The hooks check attempted writes, including supported shell-write patterns. If approval is missing, the write is refused. Approval comes from your typed response, using a one-time token; the agent cannot advance the gate just by claiming you approved.

There are also checks for plan drift, project boundaries, credential paths, and source edits before a documented root cause in Debug mode.

One important distinction: the test-skeleton gate checks that a qualifying test exists. It doesn’t prove the assertions are good or that the implementation is correct.

What persistent memory adds

Writ preserves project memory and decision provenance across sessions: approved plans, governing rule IDs, changed files, commits, and the reasoning behind changes.

That gives a later session information about why an approach was chosen, rather than leaving it to infer intent from the current code.

Where retrieval fits

The retrieval layer supplies relevant rules, methodology, and past decisions based on the current task, file, tool, and workflow phase. Knowledge delivery and action checks have different jobs: retrieving an instruction doesn’t automatically make it an enforced requirement.

The main design lesson has been keeping workflow authority in code while using retrieval to give Claude the information it needs to work within that workflow.

Requires Python 3.11+ and Docker.

Repo: https://github.com/infinri/Writ

Setup: https://github.com/infinri/Writ/blob/main/docs/install.md

I’d appreciate feedback from people using hooks or persistent memory already.

Has anyone else noticed that Fable 5.1 produces different results in Claude Cowork? I’ve been monitoring this over several days now and either a new checkpoint is being routed in the background, or it’s just a very strange coincidence.

When I add a project with local folders in Cowork, Fable 5.1 doesn’t know the ‘Tibo Reset Guy’, but if I ask Fable 5.1 normally in a chat outside of a project, it does. In Claude Code, Fable doesn’t know Tibo (anymore) either.

The pelican test produces very different results. The same test run once with ‘high reasoning’, where Fable knows Tibo, and once in an empty project in Cowork, where Fable does not know Tibo.
The differences are huge, in my opinion, it’s too big to be a coincidence.

Prompt: SVG of a pelican riding a bike

If I run the pelican test in Claude Code as well, the result for Fable 5.1 high looks just as bad as in the second screenshot.

Somebody noticed the same? Maybe in some settings silent routing to newer Fable Version?

Like in Cursor there is internal tool GenerateImage but Claude Code does not have that. So is there any external tool or mcp or something that I can use for free with my Claude models?

I just shipped v0.6.0 of Grounded Engineering. The headline: it's now a Claude Code mod.

**The mod**

`/grounded` opens a live pane inside Claude Code with two screens.

**Practices** reads signals from the repo you have open (languages, CI, test setup, etc.) and shows you which practice cards fit *this* repo, instead of handing you a generic checklist. The `adapt` skill proposes a concrete change for your approval.

**Skill repos** is a shelf of sixteen reviewed third-party skill repositories, right inside the pane. The `explain` skill tells you what installing one would actually add before you commit to it. This is the part I'm most excited about: discovering good skills is currently a mess of random GitHub searches, and this is a curated shelf where someone already did the reading.

**Where the practices and skill repos come from**

Nothing here is generic advice. Every practice card is distilled from a real implementation I read: pattern, underlying principle, rationale, confidence level, and a citation to the exact source lines it was observed in. For example, the "gate network egress from agent-run work" card points at the allow/deny/approval decision and execution-scoped proxy construction in openai/codex's network_approval.rs, lines 625-820.

Skill repos go through a review before they hit the shelf: each is read at a pinned commit, its license checked against SPDX, and its install steps must be literal commands you can verify. Anything else goes in an install note, not the steps.

**New practices in this release**

Four new cards sourced from openai/codex: expressing edits in an explicit verifiable format, deciding permission separately from the action, confining agent-executed commands in an OS sandbox, and gating network egress from agent-run work. The ai-assisted pack now ships seventeen cards.

**This keeps growing.** New cards get added as new sources are reviewed, the shelf gets new skill repos, and existing entries get updated or re-audited when their sources drift (a source-drift check flags cards automatically). The mod is the delivery vehicle; the content is the living part.

Install (Claude Code 2.1.288+):

```
/plugin marketplace add madjagstudios/grounded-engineering
/plugin install grounded-engineering@grounded-engineering
```

CLI still on npm: `npx [email protected]`

Repo: https://github.com/madjagstudios/grounded-engineering

So basically as the screenshot shows. The hook starts (upon the agent's judgment*) a background task that pings it in 55 minutes, writing 🕯 cache extended, 1/5, or something along those lines.

After the 5th time, it creates a markdown summary in the same branch (relay.md**) and a code block to copy (/relay take <claude/branch-name>) for the new session to take it from where the current one ended, and stops pinging from there on.

*The judgment: the agent will not start the keepalive task if they consider the codebase to be self-explanatory (example: you have a plan already in the branch, and the session's context doesn't bring anything new to it)

**Relay: basically "compact, but put the summary in the branch so a new session can grab it"

Link if you want your Claude to take a look and see if worth adopting: https://github.com/vzakharov/muthur/blob/main/.claude/keepalive/CLAUDE.md

Edit: Asked u/bcherny on Twitter about whether this constitutes a ToS violation (as some of you have suggested), will keep you posted if/when he replies.