GitHub Trending Top 10: Skills, rooms, worlds, and a mesh chat (Jul 26–Aug 2)

The top ten this week do not form one clean category. They form a set of interfaces: books become agent skills, a branch becomes a room, code review becomes a deterministic-plus-agent pipeline, a building becomes a programmable scene, and a phone can become a mesh relay. The strongest projects are not simply adding another model call. They are changing what software can be handed to a person or an agent. 1

Coverage: July 26, 2026 at 20:00 through August 2, 2026 at 20:00 Eastern Time. The rank and weekly star gains below are a snapshot of GitHub's live weekly page, not a permanently auditable seven-day series. The table uses that page for rank and weekly growth; repository API snapshots are used separately for license, open issues, push date, and contributor counts. Small star-count differences between the two captures are expected. 1

*Contributors are the accounts returned by each repository's GitHub contributors endpoint during this run; Airi required two pages. The ranking page is the source for rank and weekly growth. 1

Buzz treats a project workspace as a shared room for people, agents, patches, CI results, approvals, and git events. Its problem is not another chat interface; it is the loss of context when the conversation, code review, workflow run, and merge decision live in different systems. The README makes the relay the source of truth, with signed events for messages, reactions, workflow steps, and git activity. 2

The implementation is a Rust workspace around a Nostr relay, WebSocket and REST APIs, Postgres, Redis, and S3/MinIO. buzz-acp bridges ACP and MCP, buzz-cli speaks JSON in and out for agent calls, and buzz-dev-mcp exposes shell and file-edit tools. Desktop builds cover macOS, Linux, and Windows; the relay can run through a production Compose bundle. The project documents unit, end-to-end, CI, security, and architecture workflows. 2

The useful distinction is the event model: a branch can become a room rather than a link pasted into a chat. That gives an agent a durable audit trail, but it also makes the system heavier than a bot attached to an existing team chat. The API snapshot recorded 1,681 open issues, 81 contributor accounts, an August 2 push in Eastern Time, and Apache-2.0 licensing. The README says the product is unfinished and warns against using pending features for compliance planning. 3

Verdict: star it if you are studying sovereign, agent-operable collaboration infrastructure. Skip it as a drop-in Slack replacement; the deployment and unfinished surfaces are part of the bet.

Book-to-skill solves a context problem: a coding agent can search a large technical PDF, but it rarely turns that material into a durable working reference. The tool converts a book, document folder, or source collection into an installable skill with a front-loaded SKILL.md, on-demand chapter files, a glossary, patterns, and a cheatsheet. It is structure rather than a short summary. 4

The pipeline is a practical Python CLI. It accepts PDF, EPUB, DOCX, HTML, Markdown, and other formats; chooses extractors such as pdftotext, Docling, ebooklib, BeautifulSoup, or Calibre; then asks Claude to analyze the structure and generate the skill directory. validate_skill.py checks the result, discovery_tax.py measures context cost, and the repository includes pytest coverage, architecture docs, security notes, and CI gates. 4

Its edge over handing a PDF to an agent is repeatable retrieval: the chapter is loaded when needed instead of dumping the whole book into every turn. The trade-off is segmentation quality. Books without recognizable headings may not split cleanly, and the generated skill is a derivative of the source, not a license to redistribute copyrighted text. The API snapshot recorded 17 open issues, 16 contributor accounts, a July 31 push in Eastern Time, and MIT licensing. 5

Verdict: star it if you regularly learn from technical books or build agent playbooks. Skip it for a one-off reading task; the project itself says a plain PDF agent may be enough.

I-have-adhd is a small intervention with a clear target: stop a coding agent from burying the answer under a preamble, caveats, and a long recap. Its rules put the next action first, number multi-step tasks, cap lists, restate state, give concrete time estimates, and end with one next step. The result is a response protocol, not a new model or orchestration runtime. 6

The implementation is deliberately portable. The same skill is packaged for Claude Code, Codex, Gemini CLI, and other agents through plugin and skill directories, with compatibility files for Claude, Codex, Cursor, and Gemini. The repository also contains reproducible quality evaluations, test material, and a CI drift check so copied versions do not silently diverge. It is MIT licensed and explicitly says it is not a diagnosis or medical tool. 6

The difference from a generic prompt template is operational placement: the instruction can be installed at the agent layer and invoked implicitly when a task benefits from it. That makes it easy to adopt, fork, and remove, but also means the improvement depends on the host agent obeying the skill and on the team agreeing that brevity is desirable. The API snapshot recorded 19 open issues, 21 contributor accounts, and a July 31 push in Eastern Time. 7

Verdict: star it if agent output is slowing you down more than model quality is. Skip it if your work needs exploratory explanations by default; terse output can hide uncertainty when applied blindly.

AI-For-Beginners is a curriculum, not a model tutorial dressed up as a repository. It lays out 12 weeks and 24 lessons across symbolic AI, neural networks, computer vision, NLP, genetic algorithms, multi-agent systems, and AI ethics. The lessons combine reading, executable Jupyter notebooks, and labs, with examples ranging from perceptrons and CNNs to embeddings, Transformers, and reinforcement learning. 8

Its implementation choice is breadth with runnable artifacts. The material touches TensorFlow, PyTorch, Keras, OpenCV, BERT, Word2Vec, GloVe, CLIP, VQGAN, U-Net, GANs, RNNs, and Transformers. It ships 50-plus language translations, beginner examples, VS Code and Codespaces setup, Binder/devcontainer files, and a quiz app that can run locally or on Azure. The translations are maintained through GitHub Actions, while the repository remains MIT licensed. 8

That makes it different from a framework-first course: the learner sees several families of techniques before committing to one cloud stack. The cost is deliberate omission. The README excludes classic machine learning, business use cases, cloud ML frameworks, conversational AI, and deep mathematics. The API snapshot recorded 16 open issues, 73 contributor accounts, and a July 21 push in Eastern Time. 9

Verdict: star it as a map for a beginner or a mentor. Skip it if you need production deployment guidance or a deep course in one specialization.

AI Agent Book is the week's largest learning signal by weekly growth: the Trending page shows 9,298 new stars. The repository packages a ten-chapter book, compiled PDF and EPUB editions, and 95 companion experiments around a simple formula: an agent is an LLM plus context plus tools. Its chapters move from context engineering and memory to coding agents, evaluation, post-training, multimodality, and multi-agent collaboration. 110

The engineering pattern is a book that behaves like a reproducible lab. Chapter-specific Python environments use uv extras, experiments have their own READMEs, and PDF/EPUB build scripts sit beside the source. Some chapters pin external repositories to specific SHAs; others need browser, CUDA, FFmpeg, Playwright, Ollama, or newer Python versions. The repository includes 13 language versions, experiment status docs, tests, and CI-related tooling under Apache-2.0. 10

Compared with a static textbook, this gives readers an execution path and a way to inspect what has actually been completed. It is also more demanding: installation does not mean the experiments are finished, translations may lag the Chinese original, and several dependencies live outside the repo. The API snapshot recorded 6 open issues, 49 contributor accounts, and an August 2 push in Eastern Time. 11

Verdict: star it for a structured route through agent engineering. Skip it if you want a short API recipe or a model-specific cookbook.

Jcode is a Rust coding-agent harness built around a practical constraint: a developer may want several persistent agent sessions without paying the memory cost of a heavyweight desktop wrapper. It supports an interactive TUI, non-interactive runs, resumable sessions, a server/client mode, voice dictation, browser control, semantic memory, and swarms that let multiple agents work in one repository. 12

The stack is a multi-crate Rust project with provider login flows, terminal rendering, a browser tool backed by Firefox Agent Bridge, and a memory graph that stores semantic embeddings and can ask a side agent to verify retrieval. The server can notify agents when another agent edits a file they have read. CI, tests, safety docs, browser-provider docs, and architecture notes are all visible in the repository. MIT licensing covers the project. 12

Its difference from a thin CLI wrapper is that sessions, coordination, and UI state are treated as runtime primitives. That is also the risk: the surface area is wide, HTTP/SSE MCP servers are skipped in favor of stdio servers, Firefox is the wired browser backend, and terminal scrolling still has hard limits. The API snapshot recorded 185 open issues, 5 contributor accounts, and an August 2 push at 19:29 Eastern Time. 13

Verdict: star it as a reference for native, extensible agent-runtime design. Skip it if one provider and one shell loop already solve your problem.

Pascal is a 3D building editor that makes architectural geometry a data model instead of a pile of meshes. Users work through a hierarchy from site to building, level, wall, item, roof, and zone, with tools for walls, zones, furniture, slabs, and selection. The repository says the goal is to create and share 3D architectural projects. 14

The implementation is unusually explicit about scene updates. React Three Fiber and WebGPU render the scene; Zustand stores node state in IndexedDB; Zundo supplies a 50-step history; and a registry maps IDs to scene objects. A dirty-node loop updates geometry after state changes, with mitered walls, CSG door and window cutouts, collision checks, and placement validation. The TypeScript monorepo is split into core, viewer, editor, nodes, and UI packages, built with Next.js, React 19, Three.js, Turborepo, and Bun. 14

That separates Pascal from a generic 3D viewer: editing semantics, persistence, undo, and geometry systems are first-class. The boundary is equally clear. The source does not document real-time multi-user collaboration, cloud sync, or a broad sharing backend; its plugin guide also defines a limited v1 scope. The API snapshot recorded 40 open issues, 26 contributor accounts, and an August 2 push at 17:49 Eastern Time. 15

Verdict: star it if you build browser-based CAD or scene editors. Skip it if you need a mature collaborative BIM platform today.

Open Code Review combines static discipline with an agent instead of asking an LLM to improvise the entire review. It reads a diff, selects and bundles related files, matches rules to file characteristics, then lets an agent inspect context and write line-level comments. ocr scan can review whole files when there is no useful diff. 16

The stack is a Go CLI with configurable OpenAI- and Anthropic-compatible models, integrations for Claude Code, Codex, Cursor, OpenCode, and skill-compatible agents, plus CI/CD and VS Code paths. Deterministic file selection and rule matching constrain the agent; scenario-tuned prompts and tools handle the reasoning that requires context. Built-in examples include null dereferences, thread safety, XSS, and SQL injection. The repository documents delegation mode, where a user's coding agent runs the review without an OCR API key, and carries Apache-2.0 licensing. 16

The differentiation is a stated precision trade-off. The project says it uses roughly one-ninth the tokens of general-purpose agents in its benchmark, with higher precision and F1 but lower recall. That is sensible for review noise, but it means a clean report is not proof that every defect was found. The API snapshot recorded 75 open issues, 96 contributor accounts, and an August 2 push in Eastern Time. 17

Verdict: star it if review precision and predictable rule application matter. Skip it if your primary need is broad exploratory bug discovery.

Bitchat is a messaging app with two transports: Bluetooth mesh for local, offline communication and Nostr relays for internet reach. It removes accounts, phone numbers, and central servers from the default story. Bluetooth channels support multi-hop forwarding up to seven hops; location channels use geohashes and Nostr. Direct messages try Bluetooth first, fall back to Nostr private envelopes, and queue when neither transport is available. 18

The technical interest is the boundary between transports. BLE uses automatic peer discovery, adaptive power behavior, and a binary protocol; live mesh sessions use Noise encryption. Internet fallback uses BitChat-specific XChaCha20-Poly1305 envelopes inside kind-1059 events, not NIP-17, NIP-44, or NIP-59, so private-message interoperability stops at BitChat clients. The Swift app targets iOS and macOS, with tests, a technical whitepaper, build-verification docs, and an Unlicense/public-domain position. 18

Its difference from a centralized messenger is not just privacy branding; the transport can continue without internet. The costs are real: the mesh exposes a persistent per-device identifier derived from the identity key, store-and-forward mail lacks live-session forward secrecy, and builds from unknown sources cannot be verified. The API snapshot recorded 104 open issues, 57 contributor accounts, and an August 2 push at 01:52 Eastern Time. 19

Verdict: star it for offline networking and protocol design. Skip it for security-critical messaging until you have audited the whitepaper, build provenance, and metadata leakage.

Airi is a self-hosted virtual companion that treats a character as a software system with voice, memory, embodiment, and game integrations. It supports realtime voice chat, VRM and Live2D avatars, browser and Discord audio input, and agents for Minecraft and Factorio, with web, macOS, Windows, and PWA paths. The project is still early-stage and labels several integrations as work in progress. 20

The implementation is a TypeScript-heavy monorepo that leans on WebGPU, WebAudio, Web Workers, WebAssembly, WebSocket, Vue, Three.js, ONNX Runtime, and Transformers.js. Its voice layer can connect to ElevenLabs, Azure Speech, OpenAI-compatible TTS, Alibaba Cloud Model Studio, or local Kokoro. Desktop builds can use NVIDIA CUDA, Apple Metal, and candle; the repo also includes browser, desktop, mobile, docs, and game-specific components. Vitest, ESLint, cspell, Knip, Rust formatting, Turbo, and CI files provide a visible engineering base. 20

The differentiation is ownership plus embodiment: it is closer to a self-hosted character platform than a text-only assistant or a single avatar demo. That ambition creates adoption risk. Factorio, Helldivers 2, memory, and the plugin system are not all finished, and provider credentials or native acceleration change the setup. The API snapshot recorded 201 open issues, 173 contributor accounts, and an August 2 push at 12:10 Eastern Time under MIT. 21

Verdict: star it if embodied agents, local inference, or virtual worlds are your lane. Skip it if you need a stable companion product rather than an active construction site.

The chart is splitting along a useful axis: some projects package knowledge (book-to-skill, AI-For-Beginners, and ai-agent-book); others package agency (buzz, jcode, and open-code-review); the remaining entries give software a body or a new communication surface (pascalorg/editor, Airi, and bitchat). i-have-adhd sits underneath all three as a response contract for the agent itself.

The reusable pattern is a stable interface around a messy system. A relay turns collaboration into signed events. A skill turns a book into addressable chapters. A scene graph turns geometry into nodes. A hybrid review pipeline gives the model a bounded tool surface. A mesh protocol lets a message survive the loss of the internet. Those interfaces are the real reason to star these repositories: they expose design moves you can lift into your own systems.

The best first experiment depends on your work. Start with book-to-skill or ai-agent-book for learning infrastructure, open-code-review for bounded agent reasoning, jcode for runtime design, Buzz for auditable collaboration, Pascal for reactive 3D state, or bitchat for transport resilience. In every case, read the license, inspect the failure boundary, and treat a star as a bookmark for a design pattern—not as a production approval.