title: "GitHub Trending Today: Matt Pocock Publishes His Entire Claude Skills Directory and Someone Built a Git-Native Memory Layer for Agents" description: "James Chen on today's GitHub trending — mattpocock/skills leads with 2,519 stars as Matt publishes his actual .claude directory, free-claude-code finally decelerates, beads is the most technically interesting thing on the board, and GitNexus does client-side Graph RAG in a browser which is either clever or a disaster depending on your repo size." publishedAt: "2026-04-27" author: "James Chen" category: "open-source" tags: ["github-trending", "open-source", "ai-tools", "claude-code", "agent-skills", "llm", "developer-tools", "computer-use"]

Matt Pocock published his .claude directory to the internet and 2,519 people starred it before noon. That is the story today.

Not because the number is record-breaking — it isn't — but because of what the number represents. Matt runs a TypeScript education newsletter with roughly 60,000 subscribers and is known for explaining type system arcana in plain English without making you feel like a lesser being for not understanding it the first time. His audience is working engineers. When that audience stars a repository at that velocity, it means the thing being starred is solving a problem that those engineers recognize from their own daily work rather than a problem they've been told they should have.

The problem, in this case, is that your coding agent is either a vibe machine or a blank slate. Pocock's repo is an argument that it can be a third thing: a set of disciplined, opinionated behaviors that you install once and use everywhere.

mattpocock/skills: Agent Behaviors as Shareable Packages

mattpocock/skills is exactly what it says on the tin. It is the agent skills that Matt Pocock uses every day, extracted from his personal .claude directory and published as installable packages. You grab them with npx skills@latest add mattpocock/skills/<skill-name> and they drop into your project's configuration, at which point your agent knows how to do the thing the skill describes.

The tagline is "real engineering, not vibe coding," which is doing a lot of work but is not inaccurate. The skills themselves break into planning and development categories. On the planning side: to-prd synthesizes your current conversation into a PRD and files it as a GitHub issue without an interview; to-issues takes a plan and slices it into independently-grabbable GitHub issues using vertical slices rather than horizontal layers; grill-me interviews you relentlessly about a design decision until every branch of the decision tree is resolved. On the development side: tdd runs a red-green-refactor loop and builds features one vertical slice at a time; triage-issue explores the codebase, identifies a root cause, and files a TDD-based fix plan rather than just describing the symptom.

What's actually interesting here is not the individual skills but the distribution mechanism. The fact that you can npx install a set of agent behaviors and have them apply to your existing agent setup is new. A month ago this would have required forking someone's entire dotfiles repo and hoping their assumptions about project structure matched yours. The skills format abstracts that away — you install the behavior, not the configuration.

The 25,000+ total stars suggest this has been building for a while, but the 2,519 added today suggests it hit a new distribution channel. My guess is a newsletter drop. Engineers who have been running Claude Code for a few months are now at the stage where they want to stop re-prompting the same planning workflows from scratch. This scratches that itch directly.

Worth cloning? If you are using Claude Code daily and you keep re-establishing the same planning rituals at the start of each session, yes, absolutely. The grill-me skill alone is worth it if you have a tendency to start writing code before you've actually thought through the edge cases.

free-claude-code Finally Decelerates

Yesterday I updated my priors when Alishahryar1/free-claude-code went from 2,638 to 4,007 stars in a single day despite my prediction that it would flatten out. Today it pulled 1,701. The prior update stands but my original expectation was directionally correct — it just took an extra day.

14,500 total stars in a week or so is not a sign of failure. It is a sign that the initial discovery wave exhausted itself and the sustained daily rate is settling around 1,000 to 1,500 as it gets picked up by second-tier referrers. The repo itself hasn't changed materially. It still routes Claude Code's API calls through a proxy that handles NVIDIA NIM's free tier, OpenRouter, DeepSeek, or local inference backends, and it still depends on the heuristic tool call parser to catch models that leak their tool responses as prose instead of structured JSON.

If you are evaluating Claude Code but sitting out because of the subscription cost, this is still worth running. Just don't expect it to feel identical to the real thing when routing through a smaller model in an agentic loop. The interface is Claude Code. The brain depends on what you point it at.

gastownhall/beads: Git-Native Memory for Agents That Actually Works

This one is sitting at 152 stars added today against 21,836 total, which means it has been around for a while and hit something today that bumped it. The description says "memory upgrade for your coding agent" and I would have dismissed that as marketing if the implementation weren't genuinely interesting.

gastownhall/beads is a distributed graph issue tracker for AI agents, built on top of Dolt. If you don't know Dolt: it is a SQL database with full git semantics — branching, merging, diff, clone — at the cell level. You can dolt diff between two database states the same way you git diff between commits. Beads uses this as its storage layer for agent task graphs.

The core insight is that todo markdown files are the wrong abstraction for long-horizon agent tasks. A markdown list has no structure. It can't express dependencies. It can't prevent two agents from claiming the same task simultaneously. It can't summarize itself as it grows. Beads replaces that with a dependency-aware graph where tasks have hash-based IDs to prevent merge collisions (bd-a1b2 format), explicit dependency links (blocks, related, parent-child), and a compaction mechanism that semantically summarizes closed tasks when they start consuming context window. Tasks support threading. There's an MCP server so your agent can interact with the graph directly through tool calls.

The bd ready command is the one I find most practically useful: it lists tasks that have no open blockers, so an agent can immediately pick up work without reasoning about the dependency graph itself. bd update <id> --claim atomically sets assignee and status in one operation, which matters in multi-agent workflows where two instances racing toward the same task is a real failure mode.

Stealth mode — bd init --stealth — lets you use this on shared repos without committing Beads artifacts to the main branch. For those of us who do not particularly want our issue tracker living in the same repository as our source code, this is thoughtful.

Is it worth setting up? Yes, if you are running agents on tasks that span more than a single session. The moment you find yourself re-reading a markdown plan to remind your agent where it left off, that is the moment Beads pays for its setup cost.

GitNexus: Client-Side Graph RAG, Ambitious Boundary Conditions

abhigyanpatwari/GitNexus picked up 700 stars today against 30,464 total, so this is not new, but something pushed it into trending today. The pitch: drop a GitHub repo URL or ZIP file into a browser, and GitNexus constructs an interactive knowledge graph of the codebase client-side, entirely without a server. The graph has a built-in RAG agent so you can ask questions about the code.

The "entirely in your browser" part is the technically interesting constraint. No server means no backend costs, no data leaving your machine, and no deployment headaches. It also means the graph construction runs in your browser tab, which is fine for small repositories and begins to raise questions for anything with more than a few hundred files. JavaScript is not ideal for the kind of embedding generation and similarity search that Graph RAG requires at scale, and WebAssembly can only carry so much weight before you're staring at a spinner for two minutes.

For exploring a new codebase you've been dropped into — a legacy project, a dependency you need to understand, an open source library you're contributing to — this is useful. The interactive graph visualization is genuinely helpful for understanding how components relate to each other before you start reading individual files. The RAG agent saves you the "where is the authentication middleware actually defined" query that would otherwise require grep or IDE search.

My skepticism is reserved for large repos. If you are trying to build a knowledge graph of a monorepo with half a million lines of code, you will run into browser memory limits before you get a useful result. The repo does not clearly document its scale boundary, which is exactly the kind of thing you want to know before you paste in your largest codebase and wait.

Worth trying on medium-sized repos: yes. Worth treating as a production-grade code intelligence layer: not yet.

openclaw/openclaw: The Lobster Is Still Trending

openclaw/openclaw pulled 627 stars today. It continues to be described as "Your own personal AI assistant. Any OS. Any Platform. The lobster way." The lobster branding is a bit of a bit, but the underlying project — a local-first AI assistant with multi-platform support — is straightforward enough. It also appears to be the infrastructure that free-claude-code and the free-claude-code Discord community are routing through, which explains why it surfaces alongside that repo in trending.

The Discord angle is interesting. Running an AI assistant through a Discord bot interface is an unusual design choice but not an irrational one. Discord bots are easy to deploy, have a mobile app, support threads, and give you a message history that persists across sessions without any additional work. For users who don't want to manage a separate application, the Discord surface is actually lower friction than a dedicated app once it's set up.

I haven't run this in anger. The star count trend suggests a real community is using it, which is more evidence than most things at this star count have.

ComposioHQ/awesome-codex-skills: The List for Codex, Not Claude

ComposioHQ/awesome-codex-skills added 517 stars today against 2,226 total. It is a curated list of practical Codex skills for automating workflows across the Codex CLI and API. If mattpocock/skills is the Claude Code answer to reusable agent behaviors, this is the Codex equivalent.

The comparison is interesting. Matt's repo is his personal skills directory — opinionated, curated, reflects one engineer's actual workflow. Awesome-codex-skills is a community list, which means broader coverage and more variable quality. You will find skills that solve your specific problem alongside skills that were submitted because someone wanted to see their name on the list.

That is not a criticism of the format. Awesome lists have been the standard pattern for community knowledge aggregation since awesome-python, and they work. You just have to apply your own judgment to the individual entries rather than trusting the list as a whole.

If you are using Codex CLI and you find yourself repeatedly re-prompting the same sequences, this is the place to start before building something custom. Something on the list probably already does 80% of what you need.

trycua/cua: Computer-Use Agent Infrastructure That Isn't Just a Demo

trycua/cua added 182 stars today against 14,546 total. The project is open-source infrastructure for agents that control full desktops — sandboxes, SDKs, and benchmarks for training and evaluating agents on macOS, Linux, and Windows.

The piece I find most practically interesting is the Cua Driver: background computer-use on macOS that does not steal cursor focus. If you have run computer-use agents in demo mode, you know the fundamental problem — the agent takes over your mouse and keyboard, you can't use your computer during the session, and any accidental input from you breaks the trajectory. Cua Driver avoids this by operating in the background on non-AX surfaces including Chromium web content and canvas-based tools like Blender and Figma.

The session recording as replayable trajectories is good for evaluation. If you are trying to build a reliable computer-use agent for a specific workflow, you need ground-truth trajectories to benchmark against. Most projects in this space skip that infrastructure because building it is boring, and then they can't tell whether their agent is getting better or just appearing to get better in the demos they choose to run.

Worth engaging with if you are building computer-use agents seriously. The benchmark infrastructure alone is worth the time investment if you're trying to do this rigorously rather than as a proof of concept.

The theme today, if there is one: the engineering community is starting to treat agent behaviors as first-class software artifacts. Skills you install, memory layers with proper data structures, evaluation infrastructure for agent trajectories. The vibe coding wave is real, but running underneath it is a quieter movement of engineers who want to know that their agents are actually doing what they think they're doing, consistently, across sessions. That's the thing worth paying attention to.