Week 23: 5 GitHub Repositories Every Developer Should Know in 2026

Some developer tools save hours by automating complicated tasks. Others save a few seconds every time you use them. Over a working week, those smaller improvements can add up.

This week’s collection includes a coding-agent skill that changes how AI responses are presented, a collaborative knowledge base, a tool that lets coding agents inspect videos, a self-hosted photo library, and a specialized inference engine for running large AI models locally.

For Week 23 of my GitHub Repository Series, these are the five projects worth exploring:

One licensing detail worth noting: Outline’s current repository uses the Business Source License 1.1, which is source-available rather than an OSI-approved open-source license. I’ll cover that distinction in its section.

Let’s get into the repositories.

GitHub: ayghri/i-have-adhd

You ask an AI coding assistant to fix a failing test.

Instead of giving you the command to run or the line to change, it explains the background, discusses several possibilities, repeats what you already know, and finally gives you the next step.

The answer might be technically correct. You still have to work to find the part you need.

The i-have-adhd repository addresses this specific problem.

It’s a skill and plugin for coding assistants that changes how they structure their responses. The goal is to make answers easier to act on by putting the next action first and removing unnecessary preambles, tangents, and recaps. The project includes integrations for multiple coding-agent environments.

Its rules include:

The repository includes examples showing how a long explanation can become a short set of numbered instructions.

AI coding assistants have become part of the daily workflow for many developers. Their usefulness depends partly on how quickly you can understand and apply their answers.

Consider debugging an authentication issue.

A less focused response might explain the middleware, token validation, cookies, and several possible approaches before suggesting a fix.

With the skill’s response rules, the agent is encouraged to lead with the relevant file, the action to take, and the test to run.

That is especially useful when you already understand the codebase and need help with a specific task.

During debugging: Get the likely next action and relevant file location upfront.

During implementation: Follow numbered steps rather than searching through long explanations.

During code review: Receive concise findings that are easier to turn into fixes.

During onboarding: Ask for bounded instructions when learning an unfamiliar repository.

This project doesn’t improve the underlying model’s reasoning or guarantee correct code. It changes the response format, which can make the output easier to use.

You can also customize the skill to suit your team’s preferences.

The trade-off is that concise answers aren’t always best. Architecture discussions, security reviews, and complex debugging sessions often need detailed reasoning. In those situations, ask the agent for a thorough explanation rather than relying on the default style.

The name refers to an ADHD-friendly output style, not a medical product or a treatment for ADHD.

Explore this repository if your coding assistant regularly makes you scroll past its answer to find the action you need.

GitHub: outline/outline

How many times have you searched Slack or a project repository for a decision someone made three months ago?

Maybe it was an API convention. Perhaps it was a deployment procedure or an explanation of why a particular service exists.

If that knowledge lives only in conversations, finding it again becomes harder as the team grows.

Outline is designed to make shared team knowledge easier to create, organize, and maintain.

Outline is a collaborative knowledge-base application built with React and Node.js. It provides a workspace where teams can create and maintain documentation rather than relying entirely on individual Markdown files or scattered conversations. The project supports self-hosting, and the company also provides a hosted service.

Developers can study the repository to understand how the frontend and backend fit together, how the application is tested, and how its production deployment is organized.

Documentation is useful only when people can find it and keep it current.

A team might have setup instructions in a README, architecture notes in a design document, incident procedures in a wiki, and project decisions buried in chat.

A shared knowledge base gives those materials a more consistent home.

For example, a team maintaining several Node.js services could document each service’s responsibilities, environment variables, dependencies, deployment steps, and troubleshooting procedures in one place.

New developers have a reference to follow, and existing team members have fewer reasons to repeat the same explanations.

During onboarding: Document local development setup, repository structure, and essential workflows.

During design: Record architectural decisions and the reasoning behind them.

During operations: Maintain runbooks for deployments, incidents, and common failures.

During maintenance: Update documentation as APIs, dependencies, and infrastructure change.

Outline helps teams move knowledge out of informal conversations and into documentation that can be maintained.

It’s also an interesting codebase for developers who want to study a full-stack React and Node.js application.

There is an important licensing limitation, however. The repository’s current license is Business Source License 1.1, with restrictions that include commercial document-service offerings. The license specifies a future change to Apache 2.0 for the covered version.

Self-hosting also means taking responsibility for deployment, configuration, updates, and backups.

Consider Outline when your team needs a dedicated knowledge base and you’re comfortable with its deployment and licensing requirements.

GitHub: bradautomates/claude-video

A developer sends you a video of a bug.

The problem occurs after several actions, and the useful details are spread across the recording. You could watch the entire video, write down the important moments, and then explain them to your coding assistant.

Or you could give the agent a tool for processing the video itself.

That’s the idea behind the /watch skill in this repository.

Claude Video provides a video-watching skill for coding agents. A video URL or local file is processed into evidence that an agent can use to answer questions about its contents.

Depending on the selected engine, the workflow can extract timestamped frames and a transcript or use Google’s Gemini video model to analyze the video. The project supports Claude Code, Codex, and other compatible local agent environments.

In the local workflow, the tool uses utilities such as yt-dlp and FFmpeg to retrieve media, extract frames, and prepare audio transcripts. It prefers available captions and can use local or cloud transcription options when needed.

Coding agents are good at inspecting files and reading logs, but a screen recording contains information that isn’t present in source code.

A video can show a sequence of clicks, a UI state transition, an error message, or the precise order in which a bug occurs.

With Claude Video, you can provide that recording as evidence and ask the agent to identify relevant timestamps, explain the sequence, or connect what happened in the video to the source code you’re investigating.

During debugging: Analyze a recording of a reproducible UI issue.

During onboarding: Ask questions about a recorded walkthrough of a codebase or development environment.

During research: Review conference talks, tutorials, and demonstrations.

During product development: Extract the important steps from a product demo or user workflow.

The skill reduces the manual work required to turn a video into useful context for an AI agent.

It also makes video a more practical input for coding workflows, particularly when visual evidence matters.

There are limits. Frame extraction can miss brief visual changes, and transcripts alone cannot establish what happened on screen. The selected engine also matters for privacy: the Gemini workflow uploads video to Google’s service, while the local engine processes frames and transcription on your machine. Cloud transcription providers may receive audio when used as a fallback. The README explains these differences, along with supported agent environments.

Try Claude Video when you routinely work with screen recordings, tutorials, or other video material that your coding agent needs to understand.

GitHub: immich-app/immich

Photos accumulate quickly.

Phone backups, family albums, videos, screenshots, and years of personal media can eventually become difficult to organize. Many people rely on hosted photo platforms, but that means relying on another service to store and organize their collection.

Immich offers a self-hosted alternative.

Immich is a self-hosted photo and video management solution with web and mobile applications. It supports media uploads, automatic mobile backup, albums, sharing, metadata inspection, and search using information such as objects, faces, and image embeddings.

Its feature set includes support for RAW formats, map views, duplicate detection, shared albums, and a timeline for browsing media.

The mobile applications can back up selected albums, while the web interface provides tools for managing and exploring the library.

Immich is useful as a personal media platform, but it is also a practical example of a self-hosted application with several interconnected components.

The system has to receive uploads from devices, organize large media collections, extract metadata, and make searching and browsing responsive.

Its source code can be useful to developers interested in studying a full-stack application involving storage, mobile clients, web interfaces, background processing, and AI-assisted media search.

For personal infrastructure: Keep a photo and video library on hardware you control.

For mobile applications: Explore automatic uploads and media synchronization.

For full-stack learning: Study how the server and clients work together.

For media search: Explore metadata, facial recognition, object search, and CLIP-based image search.

Immich gives users an integrated way to organize and search their collections instead of building a collection of separate media tools.

For developers, the repository offers a substantial real-world project to explore, contribute to, or learn from.

There is one operational warning worth taking seriously: Immich should not be your only copy of important photos and videos. The project explicitly recommends following the 3–2–1 backup approach. Self-hosting gives you control, but it also means planning independent backups, testing recovery, and maintaining the server.

The repository uses the AGPL-3.0 license, so developers integrating or redistributing modified versions should understand their obligations.

Explore Immich if you want a self-hosted media library or an example of a sophisticated application built around photo and video management.

GitHub: antirez/ds4

Running a large language model locally is partly a model-selection problem and partly a systems-engineering problem.

The model needs enough memory, a compatible execution backend, efficient handling of its weights, and an inference path that performs well on the available hardware.

The ds4 project focuses on a narrower problem than general-purpose model runners: efficient local inference for selected large models.

The repository describes DwarfStar, the engine behind the project, as a native inference engine optimized first for DeepSeek V4 Flash. It also supports selected versions of GLM 5.2 and, on very high-memory systems, DeepSeek V4 Pro.

The implementation is deliberately specialized rather than a general-purpose GGUF runner. Model loading, prompt rendering, tool calling, KV-cache state, the HTTP server, and the coding agent are developed together for the supported models.

The repository supports multiple hardware paths:

It includes a CLI for interactive use, a coding-agent interface, and a server with API endpoints compatible with OpenAI- and Anthropic-style clients.

Most developers encounter local AI through a convenient general-purpose application. Engineers interested in inference systems may want to look deeper at how the model executes, how context is cached, and how hardware affects performance.

ds4 is interesting because its narrow scope allows it to optimize for specific models and supported hardware configurations.

The README also describes SSD streaming for systems that cannot keep all model weights in fast memory. This can make inference possible on smaller configurations, although storage cannot match the speed of RAM or GPU memory.

During systems experimentation: Study native inference, memory management, and model-specific optimizations.

During local AI development: Run supported model weights on compatible Apple Silicon or GPU systems.

During agent development: Test coding-agent workflows against a locally served model.

During infrastructure research: Explore quantization, KV-cache handling, and multi-GPU execution.

For developers interested in inference internals, ds4 offers an implementation to examine rather than treating the model runner as a black box.

The server interface also provides a path for connecting supported models to applications and coding tools.

This is a specialist project, though. Its model support is intentionally narrow, and the README describes the software as beta quality and fast-changing. The primary Apple Silicon target is a machine with at least 96 GB of memory; the recommended configurations for some model variants require substantially more. You also need the exact supported model files and the appropriate backend.

Explore ds4 if you’re interested in the engineering behind local frontier-model inference and have compatible hardware. For a general local LLM setup, a broader runtime may be easier to start with.

These repositories solve different problems, but all of them influence how developers work.

i-have-adhd changes the format of an agent's responses so its instructions are easier to follow.

Outline provides a place to preserve a team’s knowledge.

Claude Video lets coding agents use video evidence.

Immich gives users control over their photo and video libraries.

ds4 opens a window into specialized model inference on local hardware.

Together, they cover several layers of a practical developer environment:

This is a conceptual view rather than a claim that the projects integrate automatically.

The practical lesson is to look for friction in your own workflow. Sometimes the best fix is a new infrastructure component. Sometimes it’s a small skill that makes an existing AI assistant easier to work with.

If your coding agent tends to bury useful answers in long explanations, start with i-have-adhd.

If your team needs a shared knowledge base, evaluate Outline and review its license before adopting it.

If you’re debugging visual problems or studying recorded demonstrations, try Claude Video.

If you want to manage your personal media on infrastructure you control, explore Immich.

If local inference internals interest you and you have suitable hardware, inspect ds4.

A developer’s workflow is shaped by the tools around the code.

Clear instructions help you act on AI responses. Good documentation prevents repeated explanations. Video-aware agents can use visual evidence, self-hosted applications give you more control over your data, and specialized runtimes offer new ways to experiment with local models.

These five repositories approach those needs from different directions.

Pick the one that addresses a problem you already have, try it on a small task, and evaluate whether it makes your workflow easier to maintain.

I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.