Best GitHub Repos for AI Developers to Star in 2026

I keep a running list of repos worth coming back to. This year it filled up faster than usual.

Part of it is the AI wave. But there's something more specific going on: open source having a real resurgence. The Eclipse Foundation's 2026 predictions put it plainly. Enterprises that spent two years on proprietary AI pilots are moving back to open source because the closed tools can't connect to their actual systems.

Search "best GitHub repos" and you'll get the same results everywhere. You've already seen them. This is a different list: ten repos that are specifically worth paying attention to in 2026 if you're building with AI. These are the best GitHub repos 2026 has to offer for that.

Bumblebee is a read-only supply chain scanner from Perplexity AI that checks your dependencies, MCP servers, and editor extensions for suspicious packages in seconds.

The supply chain attack surface has expanded dramatically with the rise of AI tooling. It is not just npm packages and PyPI anymore. MCP servers are being installed by developers who clicked a link in a Discord post. Browser extensions have access to every page you load. Editor extensions have access to your entire file system. Perplexity shipped Bumblebee to scan all of these at once: one tool covering npm, PyPI, Go modules, RubyGems, Composer, MCP servers, VS Code extensions, and browser extensions in a single pass.

What stands out is the architecture: written in Go 1.25, zero non-standard library dependencies, read-only by design, no unexpected network calls. It is exactly the kind of tool you run in CI without worrying about what it might be doing on the side.

At 2.6k stars (and growing fast since the v0.1.1 release in May 2026), it is still early. But given that MCP adoption is accelerating and most developers have no reliable way to audit the servers they install, this repo fills a real gap right now.

• npm / PyPI / Go / RubyGems / Composer: scans package manifests across all major ecosystems
• MCP servers: checks installed MCP servers against known-malicious and suspicious registries
• Editor extensions: audits VS Code extensions installed on the machine
• Browser extensions: scans browser extension inventory for known threats
• Zero dependencies: pure Go standard library, no supply chain risk in the scanner itself
• Read-only: makes no changes to your environment, safe to run anywhere

Install:

# Requires Go 1.25+
go install github.com/perplexityai/bumblebee@latest
 
# Run a supply chain scan
bumblebee scan

Honest take: For any developer who has been installing MCP servers from GitHub repositories and community Discords, this is the tool that should have existed from the start. The scan is fast, the output is readable, and the zero-dependency architecture means you can actually trust what it is doing. The caveat is that it is pre-1.0, so detection coverage is still being built out. Treat it as a fast first-pass audit, not a definitive security guarantee.

Cons: Very new (v0.1.1 as of this writing). Detection databases are still maturing. Does not yet cover every MCP registry source. Requires Go on the machine, which adds a setup step for teams working exclusively in JavaScript or Python.

Repo: github.com/perplexityai/bumblebee

Firecrawl searches, scrapes, and cleans the web for AI agents: one API family covering Search, Scrape, Parse, Crawl, Map, and Interact.

At 124k stars, Firecrawl is the clearest example of an AI-native infrastructure layer taking over from the fragmented tooling it replaced. Before it, a typical AI agent pipeline that needed web context stitched together a SERP API for search, a separate scraper for content extraction, a browser automation tool for dynamic pages, and a document parser for PDFs. Firecrawl collapsed that into one stack.

The core insight is the workflow: Find, Extract, Clean, Use. Search is the front door. It finds fresh, relevant sources from the live web and returns full page content, not just links. Scrape turns any URL into clean, token-efficient Markdown or structured JSON. Parse handles PDFs and documents. Crawl and Map provide depth and structure across entire sites. Interact handles clicks, form fills, logins, and any page that basic scraping cannot reach.

• Search: finds sources from the live web and returns scraped content in one call, not just URLs
• Scrape: turns any URL into clean Markdown or structured data. Works on the real web: JS-heavy sites, SPAs, and geo-sensitive pages
• Parse: converts PDFs and documents into usable text for downstream agents
• Crawl: follows links across an entire site and returns content from every page
• Map: discovers the full URL structure of a domain fast
• Interact: handles real browser interactions including clicks, form fills, and logins that Scrape cannot reach
• API and SDKs: production-grade Python, Node.js, Java, Elixir, and Rust SDKs
• MCP, CLI, Skills: brings Firecrawl into Claude Code, Cursor, and any MCP-compatible agent stack

Install:

# Python
pip install firecrawl-py
 
# Node.js
npm install @mendable/firecrawl-js
 
# CLI (installs to all detected AI agents on your machine)
npx -y firecrawl-cli@latest init --all --browser

Honest take: Web context is one of the most underrated parts of building a smart agent. An agent that can only reason over its training data hits a ceiling fast. Firecrawl is what removes that ceiling. The API is designed around what agents need, not what a human would use in a browser. Output formats are token-efficient by default. The file-based CLI output keeps agent context clean. The compliance posture (ZDR, SOC 2 Type 2, DPA, US data residency) matters for production deployments in a way that most web data tools have never had to address.

Cons: Requires an API key. The free tier covers 1000 credits per month, which is enough for testing but not production-scale crawls. The self-hosted option from the GitHub repo is available but adds infrastructure overhead most teams would rather skip.

Repo: github.com/firecrawl/firecrawl. Documentation and free API key at firecrawl.dev.

System Design 101 explains complex distributed systems through visuals and plain language, covering everything from API design to real-world architecture case studies for major platforms.

At 82.8k stars, this is the repo I keep coming back to when I need to explain a tradeoff quickly or refresh my understanding of how something works at scale. ByteByteGo has done a remarkable job turning dense distributed systems concepts into diagrams and short explanations that hold up at every level, from early-career engineers to senior architects preparing for a design review.

The scope is genuinely broad and the AI/ML section has expanded significantly over the past year as the team added content on vector databases, inference infrastructure, and LLM deployment patterns. What makes this repo different from a textbook is the visual design: every concept has a diagram, and the diagrams are clear enough to drop into a technical doc or use in an onboarding presentation.

• API design: RESTful design, communication protocols, and API security patterns
• Real-world case studies: Netflix, Uber, Google Search, and Twitter architecture walkthroughs
• AI and ML systems: vector databases, inference infrastructure, and LLM deployment patterns
• Database design: SQL vs NoSQL, replication, sharding, and indexing trade-offs
• DevOps and cloud: CI/CD patterns, cloud architecture, and container orchestration
• Security fundamentals: authentication, authorization, and encryption explained visually

Get started:

# Browse at github.com/ByteByteGoHq/system-design-101
git clone https://github.com/ByteByteGoHq/system-design-101.git

Honest take: This is reference material, not a course. You do not work through it linearly. The best way to use it is to search for the concept you are currently wrestling with and use the diagram to anchor your mental model. It also pairs well with the ByteByteGo newsletter and the System Design Interview books if you are preparing for interviews.

Cons: Coverage is uneven across topics. Some sections are very thorough, others have not been updated in over a year. Not a substitute for reading primary documentation or building the systems yourself. The repo is a collection of markdown files with linked images, not an interactive learning environment.

Repo: github.com/ByteByteGoHq/system-design-101

developer-roadmap is the most complete collection of community-driven engineering learning paths, and in 2026 it matters more than ever precisely because vibe coding makes it easier than ever to skip the basics.

When I was in grad school, this repo is what I used to get started with web development and frontend engineering. The structured paths gave me a clear sense of what to learn and in what order, not just a list of technologies, but a logical progression through the concepts that actually matter. I came back to it recently to look at the new tracks, and it has grown into something much larger: 355k stars, 44.1k forks, 1,508 contributors, and over 60 learning paths.

The new additions are telling. There is a dedicated Vibe Coding Roadmap, a Claude Code Roadmap, and an AI Engineer Roadmap. The community has absorbed the reality of the current moment. But the underlying engineering tracks (Frontend, Backend, DevOps, Full Stack, Android, iOS) are still there, and they still matter.

Here is why: with AI coding tools making it possible to ship working code without understanding what it does, a generation of developers is building on foundations they have never examined. The results are visible everywhere. Code that works until it does not. Architecture decisions that make no sense in context. Debugging sessions that go in circles because the developer does not have the mental model to narrow down the problem. That output has a name: AI slop. The developer prompting the AI still needs to know enough to direct it, review it, and debug it. This repo gives you that foundation.

• Frontend Roadmap: HTML, CSS, JavaScript, and modern framework learning paths
• Backend Roadmap: Node.js, Python, Java, databases, and API design in sequence
• AI Engineer Roadmap: machine learning, LLMs, vector databases, and deployment
• Vibe Coding Roadmap: structured entry path for developers coming in through AI-first tools
• Claude Code Roadmap: Claude-specific tooling and AI coding workflows
• DevOps Roadmap: containers, Kubernetes, CI/CD, and infrastructure as code

Get started:

# Interactive version at roadmap.sh
# Source:
git clone https://github.com/nilbuild/developer-roadmap.git

Honest take: The interactive version at roadmap.sh is far more useful than browsing the GitHub repo. The site lets you mark progress, discover linked resources for each node, and share your learning path. What I find genuinely valuable is that the community keeps adding tracks for new areas. The fact that there is already a Claude Code Roadmap in 2026 means this project moves with the ecosystem rather than preserving a snapshot of what was relevant in 2022.

Cons: Breadth over depth. The roadmaps tell you what to learn, not how to learn it well. The resource links vary in quality, and some point to paid courses or outdated material. Community curation is active but uneven across tracks.

Repo: github.com/nilbuild/developer-roadmap. Interactive version at roadmap.sh.

awesome-claude-skills is the fastest way to extend Claude Code with 1,000+ production-ready Claude Code skills and plugins covering everything from document processing to SaaS automation.

At 61.8k stars, ComposioHQ's collection has become the definitive starting point for any Claude Code user who wants to move beyond the defaults. The repository is curated but comprehensive: skills for document processing (PDFs, DOCX, Excel), developer tools, data analysis, business workflows, creative work, productivity, collaboration, and security auditing. It also includes 78 SaaS app automations via Composio integrations, giving you instant connections to Slack, Notion, GitHub, Linear, Salesforce, and dozens of other tools without writing the integration yourself.

The structure is well organized. Skills are grouped by category, each comes with a direct install command or link to the skills.sh listing, and the descriptions are concise enough to scan quickly. This is genuinely useful given how many skills exist and how difficult discovery is when working directly from Claude's context.

• Document skills: create and parse PDFs, DOCX, Excel, and PPTX files
• Dev tools: code review, test generation, and dependency auditing
• Data analysis: structured queries, CSV and JSON processing, visualization scripts
• Business workflows: NDA review, meeting notes, and status report formats
• SaaS automations: 78 pre-built Composio integrations for Slack, GitHub, Notion, and more
• Security: static analysis, vulnerability scanning, and secrets detection

Install:

# Via npx
npx skills add ComposioHQ/awesome-claude-skills
 
# Install a specific skill only
npx skills add ComposioHQ/awesome-claude-skills --skill document-processor

Honest take: This is the skills collection I return to regularly, not just once. The Composio-backed SaaS integrations are the most distinctive part: connecting Claude to external tools through a skill rather than setting up a full MCP server is substantially faster to get working. The downside is that Composio integrations require a Composio account and API key, which adds a dependency for the 78 automation-focused skills specifically.

Cons: Quality varies across the collection. The most popular skills are well maintained and have clear documentation. Less popular ones can lag on updates or break when Claude Code changes the skill loading mechanism. Worth spot-checking a skill before committing your team to it.

Repo: github.com/ComposioHQ/awesome-claude-skills

nanochat is Andrej Karpathy's attempt to put the full LLM training stack in one cohesive, minimal, readable, hackable, maximally forkable repository.

At 54.2k stars, nanochat has become one of the most-watched repos of 2026 precisely because it does the opposite of what most AI repos do. Instead of wrapping everything in an abstraction layer and hiding complexity behind a clean API, it surfaces everything. The full pipeline lives in one place: tokenization, pretraining, finetuning, evaluation, inference, and a working chat UI. Every step is visible and modifiable.

Karpathy puts the goal directly: "My goal is to get the full 'strong baseline' stack into one cohesive, minimal, readable, hackable, maximally forkable repo." That goal shapes every design choice in the codebase. No unnecessary dependencies. Clear separation between components. A time-to-GPT-2 leaderboard (current record: 1.65 hours) that gives you a concrete benchmark to measure against. And a cost reference that makes the whole thing concrete: training GPT-2 class models runs for around $48.

The interactive demo lives at nanochat.karpathy.ai if you want to see the end result before digging into the code.

• Tokenization: byte-pair encoding implemented from scratch
• Pretraining: full training loop designed to run on a single GPU node
• Finetuning: instruction tuning and RLHF from a pretrained checkpoint
• Evaluation: benchmarks built in, not bolted on after the fact
• Inference: generation and sampling logic, clean and readable
• Chat UI: minimal web interface for interactive testing of trained models

Get started:

git clone https://github.com/karpathy/nanochat.git
cd nanochat
pip install -r requirements.txt

Honest take: nanochat is the repo that makes you realize how much the popular LLM frameworks have abstracted away. Reading through the source builds a genuine mental model of what is actually happening inside these systems. I would recommend it to any developer who ships AI products but has never looked below the API layer. It does not teach production LLM infrastructure, but it builds the understanding that makes everything else click.

Cons: Educational, not production. The codebase is intentionally minimal, which means it lacks the optimization and fault-tolerance needed for real training runs at scale. Requires GPU access for meaningful experiments. The leaderboard comparisons only apply with specific hardware configurations.

When Karpathy launched it, the response from the developer community was immediate:

Repo: github.com/karpathy/nanochat. Interactive demo at nanochat.karpathy.ai.

design-resources-for-developers is a curated list of design resources for developers who need to build something that looks good without a dedicated designer on the team.

At 65.8k stars with an active commit history (latest commit: May 24, 2026), Brad Traversy's collection has become one of those reference repos developers return to at the start of every new project. The scope covers UI graphics, stock photos, fonts, colors, icons, CSS frameworks, CSS animations, UI components, design tools, prototyping tools, and a growing section on AI graphic design tools.

What distinguishes this from other design resource lists is curation quality and maintenance cadence. Many repos like this launch with enthusiasm and go stale within two years. This one is still being updated in 2026, which matters because the tools in this space change fast. The AI graphic design section is relatively new and reflects the current moment: tools for generating UI mockups, design systems from prompts, and assets on demand have made the developer-designer boundary blurrier than it has ever been.

• UI graphics and stock photos: free image sources with clear licensing
• Fonts and typography: directories, pairing tools, and variable font resources
• Colors and palettes: generators, tools, and curated palette libraries
• Icon libraries: SVG icon sets, icon fonts, and search tools across multiple collections
• CSS frameworks and animations: utility-first and component frameworks, animation libraries
• AI design tools: mockup generators, design-from-prompt tools, and AI asset generation

Get started:

# Browse at github.com/bradtraversy/design-resources-for-developers
git clone https://github.com/bradtraversy/design-resources-for-developers.git

Honest take: I reach for this every time I start a side project and need to pick a font stack or find a free illustration set. The value is not finding resources no one has heard of: it is having them all in one place with consistent quality filtering. The AI design tools section is worth checking even if you consider yourself more developer than designer. The gap between "developer-built UI" and "designed UI" has narrowed considerably with current tools, and this repo shows you where those tools are.

Cons: Longer list than it looks. Not everything on it is maintained or free. Some links go to tools that have pivoted, shut down, or become less competitive than alternatives. Worth opening a few links before committing to anything from the less popular sections.

Repo: github.com/bradtraversy/design-resources-for-developers

transitions.dev is an interactive collection of 12 portable CSS transitions, each shipping a copy-ready snippet and packaged as an installable agent skill.

Most AI tools are great at code and bad at design. CSS transitions are the most visible version of this problem: AI-generated animations are slow, jerky, and ignore reduced-motion preferences entirely. This is the tweet that started the conversation:

transitions.dev is the fix. At 844 stars (launched April 2026), it is a focused, single-purpose project: twelve CSS transition patterns that cover the interaction states every web app needs. Card resize, modal open and close, dropdown menus, text swap, page transitions, icon swap, success checkmarks, validation shake, avatar group hover. Each card on the site at transitions.dev has a "copy CSS" button that emits a self-contained snippet: CSS custom properties on :root, transition rules namespaced under t-* classes, and a @media (prefers-reduced-motion: reduce) guard you can paste into any project without pulling in demo-specific markup.

The same twelve transitions are also packaged as an installable agent skill, with per-transition reference files that tell the agent which pattern to reach for from natural-language descriptions like "card expanding", "shake on validation error", or "avatar stack hover".

• Card resize and Modal: smooth expand and open/close transitions with scale
• Number pop-in and Text swap: digit flip with blur, text transition with blur
• Dropdown and Panel reveal: origin-aware open/close and panel slide transitions
• Success check: path-draw SVG checkmark animation with fade, rotate, and Y-bob
• Error state shake: input shake on validation error with auto-revert to neutral
• Avatar group hover: spring falloff hover for overlapping avatar stacks
• prefers-reduced-motion: every snippet ships with a reduced-motion guard built in

Install:

# As a skill (Claude Code, Cursor, Codex CLI)
npx skills add Jakubantalik/transitions.dev

Honest take: The skill format closes the gap by giving agents precise reference for each pattern rather than letting them improvise. The repo is small, the scope is narrow, and that is exactly why it works. A general-purpose transitions library would be bloated and unused. Twelve well-specified patterns with agent-readable descriptions is actually useful.

Cons: 844 stars as of writing, so still finding its audience. Only twelve patterns, covering the common cases but not a comprehensive motion design system. The agent skill has to be manually regenerated from the source site via npm run build after any updates, which creates a small risk of drift between the site and the skill.

Repo: github.com/Jakubantalik/transitions.dev. Live site at transitions.dev.

Lenny's Newsletter/Podcast Data is a public archive of Lenny's Podcast transcripts and newsletter posts in AI-friendly markdown, built as a starter dataset for anyone who wants to build AI apps with it.

At 534 stars, this repo is different from everything else on this list. It is not a tool, a library, or a reference guide. It is a dataset. The public starter pack includes 10 newsletter posts and 50 podcast transcripts from Lenny Rachitsky's widely followed product management content, all in plain markdown files ready for RAG pipelines, Claude Code, or direct file reads. The full archive (behind a paid subscription at lennysdata.com) adds 357 newsletter posts and 301 podcast transcripts, plus MCP access and a private GitHub repo.

What is interesting here is the ecosystem that has formed around it. Nine distinct projects have already been built on this dataset: a parenting advice app that applies PM lessons to raising kids (Tiny Stakeholders), an AI agent on X that answers product questions grounded in the archive (Learn from Lenny), a skills database, a frameworks index, an AI-led customer interview tool, visual episode summaries, and more. The dataset is clean and domain-specific enough that a functional RAG app can be built from the public starter in a few hours.

• Starter pack (free): 10 newsletter posts and 50 podcast transcripts in plain markdown
• Full archive (paid): 357 newsletter posts and 301 podcast transcripts
• index.json: structured metadata with titles, dates, word counts, and podcast guest info
• MCP server: full MCP access for direct agent integration via lennysdata.com
• Auto-updated: GitHub Actions refreshes the dataset daily from the full archive
• Open for building: format is immediately usable with any RAG setup or AI coding tool

Get started:

git clone https://github.com/LennysNewsletter/lennys-newsletterpodcastdata.git
 
# Full archive and MCP access at lennysdata.com

Honest take: The plain-markdown format is the right call. The dataset is immediately usable without preprocessing or custom parsers. The breadth of projects already built on the public starter pack signals that the content quality is high for product management and growth topics specifically. If you are building any kind of tool in the PM or B2B growth space and need a real-world corpus to test with, this is a well-maintained, well-structured starting point.

Cons: The public starter is genuinely limited at 50 transcripts out of 301 total. Meaningful coverage requires a paid subscription. Newsletter posts from the past three months are intentionally excluded from the archive. Not useful if your domain is outside Lenny's editorial lane.

Repo: github.com/LennysNewsletter/lennys-newsletterpodcastdata. Full archive and MCP at lennysdata.com.

The most starred Claude Code behavioral skill on GitHub, encoding Karpathy's viral observations about LLM coding pitfalls into four hard rules.

When Andrej Karpathy posted his frustrations with AI coding agents in January 2026, it went viral immediately. Developer Forrest Chang turned the observations into a single CLAUDE.md file with four behavioral principles. The repo hit 156k stars, making it one of the fastest-growing AI workflow repositories ever. One file, zero runtime dependencies.

The skill targets the three failure patterns Karpathy called out directly: agents making silent wrong assumptions and charging ahead without checking, over-engineering that turns 50 lines into 500, and orthogonal changes that modify code the agent was never supposed to touch.

This is an Encoded Preference skill. Claude already knows how to code. The skill encodes the behavioral guardrails that stop it from confidently charging ahead with wrong assumptions or bloating a 50-line solution into 500.

• Think Before Coding: surface assumptions explicitly, present multiple interpretations, push back when warranted, stop and ask when confused
• Simplicity First: minimum code that solves the problem, nothing speculative, no flexibility or configurability that was not requested
• Surgical Changes: touch only what you must, match existing style, do not improve adjacent code, clean up only your own orphans
• Goal-Driven Execution: define verifiable success criteria before starting, transform imperative tasks into declarative goals with verification loops

Install:

Option A: Claude Code Plugin (recommended)

/plugin marketplace add forrestchang/andrej-karpathy-skills
/plugin install andrej-karpathy-skills@karpathy-skills

Option B: CLAUDE.md (per-project)

curl -o CLAUDE.md https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md

Honest take: The "Goal-Driven Execution" principle is where this file earns most of its value. Karpathy's point that "LLMs are exceptionally good at looping until they meet specific goals. Don't tell it what to do, give it success criteria and watch it go" is the most actionable reframe in here. Defining verifiable success criteria before a task instead of giving imperative instructions reduces the clarification loops substantially. The other three principles are useful but feel like things a developer could derive after a few frustrating sessions with Claude.

Cons: One file. The star count reflects virality as much as adoption. The principles bias toward caution over speed, which is right for non-trivial work but can feel overcalibrated for simple edits. Also works with Cursor via a committed .cursor/rules file in the repo.

Repo: github.com/multica-ai/andrej-karpathy-skills

If live web context is part of your agent stack, start at firecrawl.dev.