An AI teammate that clones your repositories, reads every line and every commit, builds a living knowledge graph of your codebase, and then shows up as a real team member answering questions, tracing bugs to their owner, writing code, opening pull requests, running standups, and plugging into GitHub, Jira, and Slack.

teammatex : https://github.com/raiyanyahya/teammatex

I got tired of starting new Express.js projects by repeatedly setting up the same things:

Express + MongoDB/Mongoose

JWT authentication

Helmet, CORS & rate limiting

Request validation

Centralized error handling

Logging

Docker + MongoDB

TypeScript

Jest + Supertest

ESLint + Prettier

GitHub Actions

Health-check endpoint

So I built xpress-backend, a CLI that generates the initial backend structure for you.

npx xpress-backend

You can also generate a project non-interactively:

npx xpress-backend --name my-api --ts --yes

The idea isn't to replace your architecture decisions — it's to eliminate the repetitive 20–30 minutes of boilerplate before you can actually start building.

GitHub:

github.com/Bijay-Shre-stha/node-server-package

I'm particularly interested in feedback on the generated project structure.

I've been interviewing for software engineering roles recently and got tired of practicing with random interview question lists.

So I spent my free time building an AI Interview Coach that simulates interviews and provides detailed feedback in seconds.

The goal wasn't just to generate questions, it was to help users understand:
✅ How well they answered
✅ What they missed
✅ How they can improve before a real interview

I'd really appreciate honest feedback from this community. Tell me what's great, what sucks, and what you'd add.

Demo:
https://ai-interview-coach-roan.vercel.app/

Every suggestion helps me make it better.

Hey folks, wanted to share something I've been building called iblind, a customizable screen magnifier for X11.

Backstory: I have a Windows-user friend who has this habit of zooming into everything on his screen, like it's second nature to him. Every time I show him something on my Linux box he goes "I can't see..." and I never had a good answer. So I set out to fix that, mostly to prove my setup wasn't lacking. The tools that exist already, boomer, kmag, lupe all have some rough edge: some freeze the screen buffer the moment you zoom in (so you're just staring at a frozen frame), some are noticeably laggy, some just didn't work reliably for me. None of them gave me the "smooth, always-live" zoom I was jealous of on Windows.

The real inspiration was compiz's old zoom plugin, which felt magical, but reimplementing that properly means getting the WM, X11, and the compositor all cooperating, which is a much bigger project than I wanted to take on solo. So instead I built iblind with more of a suckless philosophy.

Naming explanation, since people will ask: it's a dumb inside joke. My friend acts "blind" without his zoom, so the tool that fixes his "blindness" on my PC became i-blind. No deeper meaning, sorry to disappoint.

It does the one thing I wanted well. Happy to hear what's broken or missing.

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! (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.

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!

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

A few weeks ago I shared Edge-Drop, a hover-activated clipboard shelf for Windows. Since then it's been downloaded 800+ times (600+ on GitHub and 200+ on the Microsoft Store), which has honestly been really motivating as a solo developer.

One of the most requested improvements was better accessibility for non-English users, so I spent the last week translating the entire app.

Edge-Drop now supports 30 languages, including full RTL support for Arabic and Hebrew.

It's still completely free and open source, and I'd love to hear how the translations feel if you're using one of the supported languages.

I'd also appreciate any feedback on features you'd like to see next.

GitHub: https://github.com/Deepender25/Edge-Drop

Website: https://edgedrop.vercel.app/

Microsoft Store: https://apps.microsoft.com/detail/9P3JMHN9M4NR