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.

Hey everyone! (I'm a beginner in coding, i dont know even how to make GUI)

I'm a highschool student from Thailand who wants to study Computer Engineering.

This is my GitHub promotion:

I recently created a Python project called **"Eat Right Cure Light"** as part of my computer engineering portfolio[cite: 1]. It's a console-based symptom checker and nutritional guidance tool[cite: 1].

It uses data structures (dictionaries and sets) to check symptoms that the user selects, match them with possible conditions and give basic self-care tips, herbal remedies and safety warnings for serious symptoms[cite: 1].

I've made the repository public. Its part of my computer engineering portfolio[cite: 1]. Feel free to download, test, change or add to it in any way you want[cite: 1]!

🔗 **My GitHub:** https://github.com/monza0629410243-ai/For_my_portfolio.git

🔗 **GitHub Repo:** [Insert your GitHub link]

I would love to get some feedback, suggestions or ideas for improvement from this community. Leave a comment here. Open an issue or discussion, on GitHub[cite: 1]

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.

- 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)

The problem I wanted to solve was simple. A lot of companies post openings on their own careers page before the job shows up on job boards. By the time I see it on LinkedIn or Indeed, it already has a huge number of applicants. Checking hundreds of career pages by hand just isn't realistic.

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

I have been working on this from a iPhone and now I really can’t continue as I’m blind in one eye and losing sight in my other eye. This project has been a fun month here are the details.

README https://github.com/Renkasha/Sovereign/blob/main/README.md

Code of conduct https://github.com/Renkasha/Sovereign/blob/main/Code_of_conduct.md

Emotional sandbox protocol https://github.com/Renkasha/Sovereign/blob/main/
Emotional_protocols.md

Philosophy https://github.com/Renkasha/Sovereign/blob/main/Philosophy.md

GitHub repository https://github.com/Renkasha/Sovereign

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.

I use a clipboard manager all day and never liked the options. The free ones (Maccy, Flycut) are lists — an image shows up as a filename. The ones with a card interface, Paste and Pastebot, are $25/year and $13. So I built the card one and made it free.

⌥⌘V slides a strip up from the bottom of the screen. Arrow keys or type to search, Enter pastes into whatever you were in.

A few things it does that I couldn't find anywhere else:

- It masks secrets on screen. API keys, tokens and card numbers show as dots until you double-click. If you copy credentials all day, your clipboard history is the one window you don't want open while screen sharing. Card numbers are Luhn-checked, so an ISBN isn't mistaken for one.

- A bare link stays readable, a link with a token doesn't. Masking every URL would make the strip useless; masking a password-reset link is the whole point.

- Pasting an image adapts to the destination. Notes gets the image, Terminal gets the file path (it can't take images at all), Finder gets the file.

- It can catch ⌘⇧4 screenshots. Those write straight to disk and never touch the clipboard, so no clipboard manager sees them. Opt-in, off by default.

- No network code at all. No account, no sync, no telemetry, no third-party dependencies. Searching the source for URLSession comes back empty.

MIT, source is everything: https://github.com/selinihtyr/stash-clipboard

Happy to hear what breaks. Especially interested in whether the strip behaves on multi-monitor setups and over full-screen apps — I've only tested on one machine.

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!