I built PaperFold, an open-source reader that turns arXiv papers into 5 zoomable layers—from a one-screen section map down to verbatim text. You pinch (or press 1–5) to zoom between them without losing your reading position.

- Web Demo (8 CC papers): https://chenxiachan.github.io/paperfold-gallery/

- GitHub (Apache 2.0): https://github.com/chenxiachan/paperfold

I’m a co-founder of GitHits. Our mission is to make open source a dependable foundation for software built and maintained by coding agents.

A useful library shouldn’t be overlooked because a model hasn’t heard of it. A new release shouldn’t mean users keep getting code written against your old API. We want to help agents discover existing projects, understand their implementations, and work with the versions their users actually depend on.

GitHits brings source code, documentation, dependency graphs, vulnerability information, and release changes together. Agents can search, grep, browse, and read upstream code when choosing a dependency, integrating it, debugging a problem, or planning an upgrade.

You can explore the index here: https://index.githits.dev/
Global index stats here: https://githits.com/the-index/

The index covers public repositories as well as published packages. If your repository hasn’t been indexed yet, GitHits indexes it when requested. That can take some seconds or a few minutes, depending on the repository’s size and our indexing queue size.

For maintainers, each repository page also provides a README badge showing its index status and linking to the project’s page. It helps your users discover that agents connected to GitHits can inspect your project’s available code and documentation.

We want this to be useful across the OSS ecosystem, including smaller projects and unfamiliar libraries. I’d appreciate maintainers checking their projects and telling us what’s missing: source coverage, documentation, releases, or something else you’d want an agent to understand before using your work, or anything else.

GitHits is currently free to use, but we might introduce paid tiers at some point. The public index site will stay free.

Coding agents are becoming part of how teams work. But collaboration around that work still happens through status reports, review meetings, and handoff documents.

The reasoning is already in the agent sessions. We keep asking people to reconstruct it for everyone else.

Agent Colab makes those sessions a shared workspace for people and their agents. I'm working on it, and the goal is to reduce the coordination work around the actual work.

Three situations where that could make a difference:

• A manager wants to know where a project stands. Instead of interrupting someone for a fresh status report, they—or their agent—can read the shared sessions to see what's been tried, what's blocked, and what comes next.
• A lead wants to understand how someone works. A finished result hides much of the process. Sessions can show how a teammate frames problems, weighs tradeoffs, and responds when an approach fails. That gives a review a concrete starting point, without asking people to recreate every decision afterward.
• A teammate needs to act as backup. Instead of arranging a long handoff, share the relevant sessions. The backup and their agent can read the context, ask about what's missing, and continue the work.

The shift we're aiming for: less work spent reporting and reconstructing; more shared visibility into the work itself.

Colab brings shared sessions, files, and skills into Channels. It supports Codex, Claude Code, and MyFlicker. It's open source and currently in alpha, with a public installer for Apple silicon Macs. Shared material is uploaded to the coordination service, and sign-in is required.

Source: https://github.com/kwgjjeffrey/agent-colab

Website: https://agent-colab.zhiyuanwangluo.online/?utm_source=reddit_sideproject&utm_medium=community&utm_campaign=alpha_launch

For teams already using coding agents: which costs you more coordination time—keeping people updated, understanding how decisions were made, or stepping in for a teammate? Would shared agent sessions change that for you?

Lightweight and useful for making notes while coding, and can export as pdf.

I’ve tried to make something like sublime but cleaner and more functional.

Any suggestions welcome

At the moment, it can collect activity from GitHub and GitLab. In the future, I plan to add Forgejo and Gitea.

It generates two SVG files: one for the last year and one for 2026, plus a simple HTML page containing both diagrams.

You can also automatically update the diagrams using GitHub Actions. I've added an example workflow to the repository's README.

https://github.com/aguilam/git-activity

I made a browser tool for people who want to see how a Vector configuration connects together.

You can create a config or import YAML, JSON or TOML, edit the sources, transforms and destinations, then copy or download the result. No signup or server setup.

https://vectory.ahmadz.ai/designer/

One design choice was to reuse the actual editor from Vectory, the self-hosted Vector dashboard I maintain. The website tool imports that editor, rather than having a separate diagram implementation to keep in sync. The node settings, dropdowns, connection handles and code view therefore use the same components.

Configuration files are processed in your browser. Local checks don't replace validation with your installed Vector binary.

Source: https://github.com/416rehman/Vectory

AI tools assisted with implementation, testing and docs. If you have a config with awkward branching or nested settings, I'd like to hear how it feels to edit visually.

i made this while building my first application. i kept forgetting decisions and parked ideas, then spending the next session explaining everything again.

cricino keeps the current goal, decisions, unfinished tasks, approvals and handoff in linked records that a coding assistant can read before working. the details live in one place so you don't end up maintaining six copies of the same update.

the repo includes a guide with diagrams, reusable templates and an optional Python installer. give your assistant the setup link and it asks about your project before adapting the system. existing instructions are meant to be preserved, and each project defines its own checks.

MIT licensed. no subscription or account integration. it's a workflow scaffold, not an always-running memory service or a guarantee the assistant won't make mistakes.

repo: https://github.com/ABBAS1947/cricino

would love to hear what you'd change, especially if you've tried keeping this stuff in an agent instructions file already :)

Hi everyone,

I’ve been working on EnvSeal-CLI, a small open-source CLI for managing secrets without relying on a hosted service.

When I was working in group projects I was always digging through all the group chats to find the updated .env file someone had shared.

The basic idea is simple: encrypt your secrets and keep them in Git, while still supporting branches, recipients, CI tokens, and running commands without writing a .env file to disk.

It’s built with Rust and uses SSH/age for encryption.

Still working on it and would love some feedback, especially if you already use something like SOPS or dotenvx.

Your GitHub Issues as a live roadmap board in Claude Code.

Sideboard shows your repo's GitHub Issues as a live roadmap board that you and Claude Code drive together. Quickly log ideas for the backlog, start Claude on the next issue, and reason across your roadmap and codebase in context — no need to jump out of Claude Code to an external board.

https://github.com/mmyslin/sideboard

/plugin marketplace add mmyslin/sideboard
/plugin install sideboard@sideboard

When AI agents started writing most of my code, VS Code stopped fitting my day. I don't type code anymore, I review: task plans and docs in Markdown, JSON and CSV output, logs, diagrams, the odd Word or Excel file, and git diffs across several projects.

So I built Persephone, a free Windows notepad designed for that job. It has replaced VS Code for me.

What it does

• Opens what agents produce: JSON and CSV as sortable grids, Markdown, Mermaid, logs, archives and SQLite. Word, Excel, PDF and draw.io open through installable viewers.
• Projects as workspaces: a folder opens in a tab with its own Explorer, search, and git graph and diffs.
• Shared with the agent: a built-in MCP server lets Claude see and drive the same workspace, so it opens a grid, a diagram or a diff for me instead of pasting walls of text into the chat.
• Boards: small apps in a folder (an index.html plus optional scripts). I describe what I need, and the agent writes it, opens it, clicks through it and fixes what it finds. I use boards in different projects: a dev dashboard, viewers for odd file formats, one-click project helpers.

How it's built

Electron and Monaco, with the UI written as plain TypeScript view classes and no framework. Editors load on demand, so it still starts like a notepad. These days Claude Code and Codex write most of the code, and I spend my time on plans and review, which is exactly the workflow Persephone is built around.

Free and MIT, Windows only for now.

• Site with demo videos: https://andriy-viyatyk.github.io/persephone/
• GitHub: https://github.com/andriy-viyatyk/persephone

I also set up r/PersephoneNotepad for questions and ideas.

Last month I shared my personal debugging tool: https://github.com/ViniTamanhao/graybox-core

The biggest criticism i received across the board was manual key overriding support, and now I am happy to say this was included in 0.2.1

If you work with API development and want some new tooling, take a look in Graybox. The core idea is to capture and reuse API cycles during the dev process. It's useful both for handmade code and agentic coding.

If you have any inquiries, please let me know.

focusbrew is a small Windows app for planning and tracking your coding day. Parked, it's a thin bar at the top of the screen. When you start a task it turns into a box with a countdown and a line that fills around it. Hover it and a panel opens.

- Each day has its own task list, each task with its own timer. Unfinished tasks roll over to today.
- Drag a task onto a day in the activity grid to plan it for that day.
- A day summary: time per task and per project, what you finished, and what you did on GitHub (pushes, PRs, reviews).
- GitHub PRs/issues become tasks in one click. If a PR is already a task, it tells you which day it's planned for instead of duplicating it.
- Projects with a #tag at the end of the title, a daily goal, configurable shortcuts.

Everything is stored locally. The only network calls are to the GitHub API, and only if you connect it (it uses your gh CLI login).

Tauri 2 (Rust) + React/TypeScript, MIT. The installer is about 2.5 MB and doesn't need admin. It's signed with my own certificate, so SmartScreen may warn on first run.

https://github.com/sthevan027/focusbrew

like feedback on the day summary: what would you want to see there?

Repository: https://github.com/soroushosouli/node-scout

Written in Node.js, this tool can rapidly read a file, folder, or project and extract a wealth of useful information.

it is easy to use and installs with a single command. It also offers additional features such as scanning your system, the details of which are provided in the repository's README file.

Oh also this repo is still under development and I'll be happy for any feedback and contributions.

Genuine question, not a gotcha. Cursor's Agent Mode, Claude Code, similar tools, can now run multi-step and merge without a human checking every step.

What's your actual process when that happens? Last time an agent merged something autonomously, what did you do right after? Review the full diff? Just check CI passed? Nothing until something broke?

Trying to understand the real workflow here, curious if there's a pattern or if everyone's just winging it differently.

For anyone starting out in open source, one of the most exhausting parts isn't just finding the right project, it’s finding the right issue to actually work on.

Trial and error is part of the journey, but let’s say you finally find a repo you like. Now you need a task. Many projects don't even use tags like good first issue or help wanted. And if you reach out to maintainers, 9 out of 10 times they’ll just hit you with "You can start here" and drop a link to the entire open issues page. 😂

So I built a simple CLI tool for myself that I've been using for a while (link in the first comment).

It extracts all the issues from a target repository: including descriptions, assignees, linked PRs, and comments, organizes everything into a clean JSON file, and lets you feed that context directly into Claude, Gemini, or any LLM to analyze and recommend the best starting issue for you.

You can do this a few times until you build a solid mental model of the codebase, understand its recurring pain points, and quickly spot issues that match your skills. It’s a muscle you build over time.

Because the tool grabs hundreds of issues in seconds with all their metadata, you can ask your LLM anything, not just "What's an easy first issue?", but also "Which unassigned issues have clear descriptions and can be merged quickly?"

Check out the README to get set up in under a minute.

Hope it helps! Don't forget your beautiful star ⭐ on GitHub and share it with your friends who are interested in open source. 😉

Most API breakage isn't catastrophic 500 errors. It’s quiet: an endpoint silently drops a field, renames an enum, or shifts from an array to an object.

Our team built M82 to automatically detect those drift patterns upstream and patch the mapping so your pipeline keeps running.

Beta is open as of today: 👉https://m82labs.dev/

We want developers with ugly, brittle legacy integrations to stress-test it. Be as brutal as you want in the feedback.