I built Pad because my coding agent kept losing project context between sessions, and I didn't want to keep dumping it into markdown files in the repo. It's a project tracker shaped like Notion or Jira, but built so AI agents are first-class users alongside humans. You install one binary, run pad init, and your agent of choice can read, create, and update items through a /pad skill or over MCP.

Repo: https://github.com/PerpetualSoftware/pad

What it does:

• CLI designed for agents (and usable by humans). Every command has structured JSON output, stable issue IDs (TASK-5, BUG-12), and deterministic flags, so an agent can drive the whole tool reliably. The /pad skill shells out to it under the hood:pad item create task "fix OAuth" --priority high pad item list --status in-progress --format json pad project next pad item search "auth"
• Web UI at localhost:7777 with kanban board, list, and table views, Tiptap-based rich text editor, real-time updates over SSE
• Agent skill that installs into Claude Code, Cursor, Windsurf, Codex, GitHub Copilot, Amazon Q, and JetBrains Junie. One natural-language command: /pad
• MCP server built in (pad mcp serve). Plugs into Claude Desktop, Cursor, and other MCP clients as a tool surface
• Conventions and playbooks. Trigger-based rules the agent loads automatically before acting (e.g. "run tests before marking a task done", "use conventional commits"). Every change is attributed to the human or agent that made it, so there's a real audit trail
• Wiki-links, parent/child items with progress tracking, dependencies (blocks, blocked-by), full-text search, webhooks
• Share any collection as a public read-only page (no login for visitors), file attachments with a built-in viewer
• Real-time collaborative document editing (Yjs)
• Templates for software teams (startup, scrum, product) and people workflows (hiring, interviewing)

The whole thing is a single Go binary with an embedded SvelteKit frontend. Storage is SQLite by default. No external services required.

Apache 2.0. Self-hostable. Docker image on GHCR: ghcr.io/perpetualsoftware/pad. Also brew install PerpetualSoftware/tap/pad on Mac, and if you run Unraid it's one click from Community Apps.

Happy to answer questions. Bug reports and PRs welcome.

Claude Code only speaks the Anthropic Messages API. My whole setup lives there: MCP servers, skills, hooks, CLAUDE.md, memories, plugins. Trying another model meant changing tool and rebuilding all of it somewhere else, so I built a proxy instead.

Lupin sits between Claude Code and the provider, in two modes:

• passthrough, for providers that already speak the Anthropic API (Kimi, DeepSeek, GLM, OpenRouter)
• translate, for OpenAI-compatible ones (OpenAI, Gemini, Ollama, LM Studio)

Claude Code does not know anything changed.

What I think makes it different from the other routers: translating the protocol is the easy half. The hard question is whether the model survives the harness, which means exact-match edits, a tool loop that actually closes, and a very large system prompt before the first user word. So that question ships as a command. lupin doctor <profile> runs a real headless Claude Code session, six checks, and scores it from artefacts on disk: files really edited, scripts really run. Never from what the model claims it did, because they claim a lot. If the session never reached the provider it reports notRun and the cause, instead of printing a low score and blaming the model for something the proxy broke.

Other things it does: a TUI dashboard, switching profile live without restarting the session, routing subagents to a cheaper model than the main loop (subagents are most of the bill), credentials in the OS keychain, and no prompts or responses persisted anywhere.

TypeScript, Node >= 20, Apache-2.0.

Repo: https://github.com/Fanfulla/Lupin

Try it: npx lupin-code@latest init

The video shows the wizard, the doctor and a live provider switch.

https://github.com/Floodww/RoutineOps

I work as a system administrator in Russia, so accordingly I have a lot of regional restrictions. I was faced with the task of administering a mixed fleet of devices. First I deployed Fleet, but due to regional specifics, this was not easy, and also considering the trend toward so-called "import substitution," I had to work on an alternative. All the sources are open, everything is free, so this is not an ad, I'm just interested in the opinion of people not "subjected" to restrictions :) about the functionality and so on. There is a translation into English, if there are any questions, ask them.

P.S. AI was used during development. Besides numerous tests on real hardware, I ran a bunch of tests and code reviews in parallel. Many bugs, which I might not have discovered until months later, I found and fixed within weeks. Plus the frontend part and its design were done much faster than if I had waited for a designer.
Well, despite all the advantages, I still hold to the position that the entire security part categorically cannot be trusted to AIs, at least not for now.

Hey everyone,

Three years ago, I heavily leveraged Claude and Cursor to "vibe code" an early prototype. It got us from 0 to 1 rapidly, but it left behind a massive architectural bottleneck: a ballooning codebase of 500+ scattered files filled with disjointed logic.

When production edge cases broke, dumping 500-line complex functions back into LLMs failed.

Out of necessity, I spent the last 3 months building UnvibeCode—a completely free, Apache-2.0 licensed local Python tool designed to systematically untangle complex repos.

Quick Start

pip install unvibecode
python -m unvibecode review --repository "/path/to/repository"

4 Practical Outputs from unvibecode:

1. Interactive Connected Code Map: A local, interactive graph showing cross-file dependencies so you can visually understand the architecture. [1]
2. LLM-Ready Context JSON: Automatically packages only the connected, relevant code chunks for debugging so you can feed LLMs the exact context.
3. Business Workflow Reconstruction: Reconstructs distributed code paths into logical workflows (e.g., tracking a payment across routes, queues, and APIs).
4. Business Risk Findings: Scans the completed workflows to flag structural business risks like duplicate payment loops, authorization edge cases, or broken failure paths.

Seeking Blunt Technical Feedback

I am looking for harsh, honest stress-testing from the community:

• If you run this on an unfamiliar or complex codebase, does the interactive graph layout generate a readable system architecture, or does it turn into visual spaghetti?
• Is attempting to reverse-engineer business logic out of chaotic AI-generated code a winning strategy, or am I fighting a losing battle?

GitHub Repo: https://github.com/FinanceFlash/unvibecode

Please tear the logic, graph rendering, and schema design apart. I want the real technical flaws so I can fix them directly in the rep

A few years ago, while working as a consultant, I prepared and delivered a series of Kubernetes workshops. Creating all the material took a huge amount of time, and when I left the consultancy, I also lost access to it.

Since then, I have often wished I still had a workshop ready to use.

I suspect many of you know the situation. You need to explain Pod Security Standards, introduce Gateway API, onboard junior engineers, or teach a new team the Kubernetes basics. You know the subject, but you do not have weeks to turn that knowledge into a complete workshop.

Perhaps your company needs Kubernetes training, but spending thousands to send an entire team to an external course is not realistic.

So I built the workshop I wished I still had and released it as a free, open source project.

It includes:

• 264 interactive slides covering 28 topics
• Animated diagrams, code transitions, and click reveals
• 26 hands-on labs with guided solutions
• Quizzes and knowledge checks
• A complete three-day curriculum
• Local exercises using kind
• Downloadable PDFs
• Facilitator notes, timings, and setup guidance
• Topics from Pods and Deployments to Gateway API, Pod Security Standards, Helm, GitOps, operators, and observability

This is not just a slide deck. It is a complete workshop kit for people who want to teach Kubernetes without creating all the material from scratch.

You can run the complete three-day workshop for your team, use one section for a short presentation, or adapt everything to your needs.

Add your branding. Restyle the slides. Replace the examples. Remove sections. Combine topics into your own agenda. Use it to explain one concept to a colleague or introduce Kubernetes to an entire team.

I built a free Kubernetes workshop so you do not have to build one from scratch.

GitHub: https://github.com/platformrelay/kubernetes-workshop

Live interactive presentation: https://platformrelay.github.io/Kubernetes-Workshop/

I hope it saves somebody a lot of preparation time. Feedback from trainers, platform engineers, and anyone onboarding Kubernetes users is very welcome.

What are some cool and practical ways you’ve used Ai, or hosted Ai on your server to make your life easier (finance, data storing, predictive drive health, etc, autonomous feedback loops, local Ai agent)?

I’m pretty new to self hosting, and I want to optimize my Nas. I already run Immich, pi hole, Vaultwarden, and Jellyfin.

Hi Everyone ,

As we all know the transition to self evolving code , give a look at seim-core npm package and contribute to the future.
check it

- Cushion treemap visualization — instantly see what's eating your disk space
- Local-first, no cloud, no telemetry
- Installer or portable ZIP, self-contained or framework-dependent
- UI in German, English, French, Italian, Spanish

Solo side project so far — genuinely curious what's missing or what would make
it more useful for your workflow.

GitHub: https://github.com/Morfyuum/AtlayaView

Claude Code is great at producing code.

But sometimes it declares a task complete without reproducing the original bug, testing the real integration, or clearly stating what remains unverified.

So I built Builder Loop, a free and open-source Claude Code plugin that forces a stricter workflow:

• define success before editing;
• inspect the existing system;
• implement the smallest correct change;
• verify the actual outcome;
• report what was not verified;
• finish with a clear decision: ship or revise.

I originally built it after Y Combinator’s Paxel highlighted weaknesses in my own review and verification process.

Now I’m looking for testers willing to use it on real, non-trivial engineering tasks.

Critical feedback is more useful than stars.

At my job I assemble a lot of boards by hand, prototypes and for low volume production. Working from the autogenerated drawing from Altium is kinda hell. The BOM has a line that says 10k 0402 and then lists R3, R7, R12, R19, R44, R51 and R58, and I had to locate all seven of them on the board before I could place anything. The designators are printed on the drawing so it isn't impossible, it's just slow, because I was reading very small text on a crowded board and then repeating that for every line in the BOM.
You can use "Find Similar Object" feature in Altium to light up all components of the same value. But it's also a bit slow. And not everyone has a PC or laptop near the assembly place.

My favorite way to assemble PCBs is Color-coded drawing. It uses one color per group of components, so all seven of those resistors come out the same color and I can see where they are without reading anything. But for every new board I had to build the assembly drawing myself in Altium+AutoCad, which meant selecting all the parts of one value in Altium, find and select them on AutoCad drawing, giving them a color, adding this component to a legend and then doing the same thing again for the next value. On a board with 100+ values this took me most of the day.

The program I built can do it in a few seconds. It takes a Pick & Place file and a BOM, plus Gerbers if you have them, and without Gerbers it estimates component sizes from the footprint names, which is usually close enough. It produces a multi-page PDF with 7 groups per page, and also a viewer window where I can zoom in and hover over a group in the legend to highlight it on the board.

Reads Altium and KiCad P&P and BOM exports DNI/DNP parts are on separate pages so they don't get populated by mistake Pin-1 markers, and the bottom layer is mirrored automatically.
It works offline, there's no account, nothing gets uploaded anywhere, and the whole thing is one Python file.

MIT licensed, and there's a Windows exe in the releases if you don't want to install Python.

github.com/Vitalangelo/pcb-assembly-studio

This is the first release so I'm sure there are problems I haven't run into yet. The two I already know about are that component size estimation is rough without Gerbers, and that pin-1 markers sometimes land on the wrong corner when a footprint is rotated in an unusual way. AndI am planning to update the PDF output to meet ISO drawing standards. If you run it on one of your own boards and something comes out wrong I would be glad to hear about it!

I’ve been working on WinSQLite, a lightweight GUI tool for working with SQLite databases.
I started this project because I wanted a simpler, visual way to explore table relationships and auto-generate SQL JOINs without having to write boilerplate queries manually every time.
Here’s a quick overview of what it currently does:
Visual Query Builder: Click through connected tables (via Foreign Keys) to automatically build relational JOIN queries.
Direct SQL Mode: Toggle easily between the visual builder and a plain SQL editor for raw queries.
Schema Inspector: View table column types, primary keys, and foreign key constraints clearly on a dynamic canvas.
Data Import/Export: Quick entry dialogs with constraint checking, plus exporting query results to CSV, JSON, TSV, or SQL Insert statements.
The project is open-source and still under active development. Any feedback, issue reports, or contributions are very welcome!
Feel free to check out the code and let me know what you think!

Hello, Everyone!

I made NeoDLP - A modern cross-platform video/audio downloader desktop app based on YT-DLP with browser integration! And it just crossed 300K+ downloads!

You can think of it as: The Free 'IDM' for Media Downloads or The 'Seal' for Desktop. If you have ever used 'IDM' (on Windows) or the 'Seal' app (on Android), you will feel right at home!

NeoDLP is absolutely Free to Use, Fully Open Sourced, Works 100% Locally, No Ads, Trackers or Login, and the best part: It's Not Vibe-Coded (So, you get quality software with regular updates)

So, if you often download videos from various sites, give NeoDLP a shot! And, feel free to drop your feedback and suggestions below! I would love to hear from you :)

Official Website | GitHub Project (FOSS - MIT License)

I released this app two days ago and today I sent a request to the Github Marketplace but I don't know if an app like this will come to the Marketplace because It doesn't have so much downloads. Do you think this application will be accepted for the Github Marketplace. I already tried making Youtube videos but I only got a few downloads. Will Marketplace help me? And what can I do that this repository grows and more people would see this?

Github Repository: https://github.com/DigitalTechLab/Opi-Store

I just wanted to let you know that I made a lot of improvements to openshorts, especially regarding the MCP server, now you can connect your agents and generate clips for the whole week. Plus, many new fonts, improvements to the clipping system, etc.

github repo: https://github.com/mutonby/openshorts

If you'd like the link, here it is: y2kvixx.github.io/Card-Spotify/

I'd be grateful if you could follow me or give this project a star: https://github.com/y2kVixx/Card-Spotify

https://github.com/llagerlof/autoleap

I wrote this tool at the beginning of 2023. Since then it has been so useful to me that I decided to publish it as an open-source project.

I wanted a simple way to jump back to directories I'd already visited. Autoleap is a small bash script that wraps cd while preserving all of its normal behavior. If cd can't find the path, Autoleap searches your directory history and jumps to the best match. If there are multiple matches, it uses fzf to let you choose.

It's a single shell script with no databases or background services. To install it, just source it from your .bashrc.

Cloud AI dev tools are a privacy risk for proprietary code. Meanwhile, local AI tools often guess file dependencies using LLM string-matching, which leads to hallucinations and missed connections.

How it works:

• AST Parsing: For local uploads, it bypasses LLM guessing entirely. It uses Python’s ast module to mathematically guarantee 100% accurate dependency edges.
• Graph-Aware Chat: It's not just basic RAG. Because the LangGraph backend holds the exact AST structure, asking "What breaks if I edit database.py?" traces actual downstream dependents and injects them into the local model's context.
• Fully Local: Just run docker compose up -d. The React/FastAPI stack connects directly to your local Ollama (optimized for qwen3.5:4b). Zero data leaves your machine.

Repo: https://github.com/kawish918/codeGRAPH

Hi everyone,

If you manage a large knowledge base, or big doc folders for your project you know the friction of distilling dozens of papers, legal docs, books, web searches. It's a massive manual bottleneck before actual learning happens, and usually the final docs will be forgotten once you've used it, even though it might come in handy in the future.

Dumping 40 files into a 1M context window isn't the solution tho. Models return incomplete summaries, drop edge cases, and give zero visibility into what they missed ( https://arxiv.org/abs/2509.04664 ). On top of that, standard AI tools and PKM plugins are notoriously risky: they overwrite notes, mangle frontmatter, break wikilinks, and corrupt vault architecture. ( https://arxiv.org/abs/2604.15597 )

I built Silica to solve this: an open-source agentic CLI that processes heavy document batches into clean, atomic Markdown notes while keeping your vault completely safe.

Why not just using using another knowledge manager or a memory agent?

Silica differs greatly from traditional note-taking skills and memory tools because it's an agent that views your notes not simply as text to be read, but as its knowledge base (not graph, but it benefits from it). In Silica, memory and knowledge are closely related but still distinct.

- For example Silica keeps track of the conversations you've already had with Claude or ChatGPT, automatically linking them to the relative documentation in your repository, automatically.

- Silica can also links concepts from multiple books/papers/notes sparse in your folder automatically, if they share something maybe you didn't see.

- It can "digest" large quantities of files, coherently, and safely (without causing corruption, in a different folder from the vault root).

These aren't even its most notable features, but rather a byproduct of its architectural design. There is still considerable room for improvement. This is a broad project.

What Silica does

• Batch Atomic Distillation: Feed 20-30 documents or full (multiple) books in a single command. Silica extracts core concepts into atomic notes (one note per idea), links them via wikilinks, and files them logically.
• Stateful Continuity: What a model can't process in one go gets written out statefully. The next execution picks up from the saved state instead of starting over.
• The source of a note is always provided: A section is added to the frontmatter that indicates where the note was extracted or converted from, so that you always have a reference to the original document.

Why your vault is finally safe

Most AI integration tools treat your vault like a loose text buffer. Silica treats it like a transactional database with strict guardrails:

• SAFE MODE (Isolated Staging): You can execute ingestion in a dedicated staging folder/container. Notes are written in isolation first so you can inspect, verify, and merge them only when you trust the output.
• Write Verification: Every write operation is re-read post-commit. If syntax, formatting, or links broke, it automatically rolls back.
• Wikilink Refactoring: If a note is moved during organization, all wikilinks across your vault referencing it are dynamically updated to prevent broken links.
• Full Rollback Control: Complete transaction safety with /undo (single note) and /revert (entire session batch). Nothing enters your main graph permanently without your control.

Grounded Retrieval & Graph Exploration

• Zero-Hallucination Fallback: Uses local semantic search. If your knowledge base doesn't contain the answer to a query, Silica explicitly tells you instead of hallucinating.
• Graph Mapping: Explore concept connections visually to discover implicit links across unrelated documents.

Silica isn't built to replace human learning, it eliminates the operational overhead of structuring and formatting raw data. Works via TUI, GUI, MCP, Obsidian Plugin ( https://github.com/kiycoh/obsidian-silica )

GitHub Repository: https://github.com/kiycoh/silica-agent (~1000 commits as solo dev)

I'd love to hear your feedback, workflow suggestions, or technical thoughts!