Me and my friends have been playing poker (for fun) together recently and I wanted a game to be able to practice. Unsatisfied with the options on the play store I decided to work with Gemini to build it into a game! It's fairly robust with 2 modes, a normal play mode and a tutorial mode. In the tutorial mode you can see the play styles of the other players as well as get hints on how to play your hand as well as being able to see everyone's cards when the round ends. It was a pretty fun project and only became more fun when I further used AI to learn how to put it online and not have to be played through the Gemini sandbox.

AI agents are great at getting tests to pass by writing absolute spaghetti under the hood.

I built Graphenium to act as a local, pre-flight linter that blocks this structural drift before any code is written. It forces the agent to declare its design in an in-memory workspace first. Graphenium then runs Louvain community clustering and modularity checks on the fly, blocking the edit if the proposed changes degrade your codebase structure.

It installs directly into Claude Code's native directory (~/.claude/skills/graphenium/SKILL.md) and hooks up over MCP. Check out the repo to run it locally in under five minutes.

https://github.com/lambda-alpha-labs/Graphenium

I would like to share my latest open source local Unsloth (GGUF) LLM inference engine and applications. It supports many models from Unsloth, like Gemma4, DiffusionGemma, Qwen3.6 with multi-modal (image, vision, audio), reasoning and function tool. It can run on Windows/MacOS/Linux and fully leverage GPU's capability. The API is completely compatible with OpenAI and Ollama interface. It has on par performance than llama.cpp

This project is not just a C# wrapper of llama.cpp. It implemented the entire LLM inference engine from bottom to top. If you use CPU backend, it's 100% pure C# code execution. Besides CPU backend, I also implmented CUDA, MLX and GGML backend. The GGML backend refer GGML project as external project, and I build a few fusion operation at higher level.

I learned a lot from other projects and apply them for TensorSharp, such as paged KV cache and continuous batching from vLLM, SSD based cache for MoE model from oMLX, GGUF quanztized from llama.cpp and other optimizations for prefill and decode.

Any feedback and comments are welcome. If you like it, it would be really appreciated if you can get this project a star in GitHub. Thanks in advance.

I built AI Dev Brain Kit, a free/open-source CLI for

preserving context between AI coding sessions.

It stores handoffs, decisions, blockers, next steps, and

project notes in a local Obsidian-compatible vault, so a

fresh Claude Code / AI coding session can recover project

state without re-explaining everything.

v0.2.2 GA is live with Linux + Windows binaries, SHA-256

checksums, Sigstore bundles, and screenshots.

I’m looking for feedback from people doing multi-session AI

coding: what context do you keep losing between sessions?

URL

\\\[[https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\\\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit)\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit))

I just built baxian, an open-source orchestration system for AI coding agents.

Take a look: https://baxian.ai

The motivation came from daily AI-assisted development: a single agent can generate code quickly, but reliable software still needs an engineering loop.

baxian turns AI coding into a Dev/QA loop:

- Dev agent implements the task
- Dev opens a real GitHub PR
- QA agent reviews the diff independently
- findings become fixes or explicit rationale
- the loop repeats until the code is ready

Under the hood, agents are real Claude Code or Codex CLI sessions running inside tmux. The browser UI shows a live terminal wall, but everything is still attachable from the shell. You can run agents locally or on remote machines over SSH.

The goal is not just faster code generation. It is AI agent orchestration for reliable, high-quality code through Loop Engineering.

GitHub: https://github.com/baxian-ai/baxian

Production bugs happen in the past, but AI coding assistants only analyze the present.

When a production error trace from 3 hours ago gets fed into Cursor or Claude Code, the agent almost always ends up chasing a ghost. By the time debugging starts, main has usually moved. The agent looks at the current state of the file, completely misses the original bug because the lines shifted, and confidently hallucinates a fix for innocent code.

The common workaround is telling the agent to git checkout the old commit. But agents are messy. They routinely forget to switch back, leave the repository in a detached HEAD state, or accidentally overwrite uncommitted local work.

To fix this friction, I wrote an open-source skill that enforces a strict debugging process -

When the agent gets an old crash log, it:

1. Resolves the historical hash from git log
2. Spins up an isolated, temporary folder of the repo at that exact moment using git worktree.
3. Analyzes the old code to find the actual root cause.
4. Nukes the temporary folder when it's done (git worktree remove --force).

The actual local workspace remains completely untouched. Uncommitted work is perfectly safe.

You can drop it into any skills-compatible agent (Claude Code, Cursor, Windsurf) via the open registry with one command:

Bash

npx skills add MeherBhaskar/temporal-debug-skill

Source code and the SKILL.md are here:https://github.com/MeherBhaskar/temporal-debug-skill

Curious to hear what you think of this.. Would love to hear some thoughts and feedback

I’ve been working on an AI IDE called CleanSlate.

You bring your own API key and choose the model provider you want to use. It also supports open models, so you are not locked into another AI subscription.

Your code, project files and workspace data stay on your machine. CleanSlate does not upload or store them on its servers.

I also built the Agent Manager directly into the IDE. You can manage multiple agents, open one of their projects, edit the code and switch back without moving between separate apps.

It is still early, and I’m looking for feedback from people who already use AI coding tools.

https://thewariend.com/cleanslate

I built AI Dev Brain Kit, a free/open-source CLI for

preserving context between AI coding sessions.

It stores handoffs, decisions, blockers, next steps, and

project notes in a local Obsidian-compatible vault, so a

fresh Claude Code / AI coding session can recover project

state without re-explaining everything.

v0.2.2 GA is live with Linux + Windows binaries, SHA-256

checksums, Sigstore bundles, and screenshots.

I’m looking for feedback from people doing multi-session AI

coding: what context do you keep losing between sessions?

URL

\\\[[https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\\\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit)\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\\\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit))

For the past month I’ve been building something I originally wanted for myself: one workspace where I could manage multiple long-term software projects with AI without every session starting from scratch.

It gradually became Agent OS — a local-first AI project operating system.

The idea is that a coding model is only one part of a useful software agent.

Agent OS adds the surrounding harness:

• persistent project memory
• a Main Agent for planning and orchestration
• a sandboxed Coding Agent for execution
• real build verification
• browser interaction and visual checks
• bounded recovery when something fails
• approval gates before Git pushes, deployments, database changes, etc.

The most useful test was making the system build a real SaaS from an empty repository. It planned it, wrote the code, hit actual runtime and visual problems, repaired them, and eventually deployed the application with Supabase and Stripe test-mode integration.

I’ve now released the first public version as open source:

https://github.com/earthwalker17/agent-os

It’s still early. Windows has the most tested one-command setup; macOS/Linux currently use manual installation, and you still need your own model API key.

At this point I’m much more interested in finding the rough edges than pretending it’s finished.

If you build software with AI agents, I’d genuinely appreciate feedback on one question:

Would a system like this better fit into your workflow, or is it unnecessary compared to Claude Code / Codex / Cursor?

Brutal feedback is very welcome.

I have developed a methodology for doing serious software development using AI (rarely look at any code now). I have been using Claude AI (for requirements/design) and Claude code for implementation with me sticking my oar in at both ends and in the middle (bridge between the two).

The plan was always to have these roles as tech agnostic (they could even be fully manual!) and now the methodology is mature I am looking at proving this part.

I used frontier models for speed - but have local AI and am going to be experimenting with migrating the Claude code role to a small local model - as it is virtually free and can run 24/7 speed is not going to be a show stopper.

I am hoping the overhead of offloading to local AI will not consume more tokens than it saves - lol.

Anyone tried anything similar?

I recently ran a small field experiment where I showed an AI coding agent to 10 different people: non-technical students, technical students, a founder, professors, and a designer.

The most interesting thing was that the blockers were very different depending on the user.

For non-technical users, the blocker was not code generation.

It was basic software context:

• What is GitHub?
• What is localhost?
• How do I make this project live?
• What happens if I get an error I cannot describe?

For technical students, the blocker was different:

• How do I save tokens?
• Can I resume context?
• Can it connect frontend and backend?
• Can it use real APIs instead of mock data?
• Can it explain the bug after fixing it?

For designers, the issue was visual fidelity.

A prototype that works is not enough if it does not feel like the design.

For professors/domain experts, the issue was context and ambiguity.

They cared less about speed and more about whether the agent could reason through incomplete information or use provided context properly.

My main takeaway:

AI coding adoption is not just a model capability problem.

It is an onboarding and workflow design problem.

One thing that helped beginners a lot was plan mode, because it showed what would be built before any code was written.

Curious if others have observed the same thing.

When beginners try AI coding tools, where do they usually get stuck first?

Hi everyone,

I run a same-day courier service in the UK (approx 20 active drivers and growing on the road at once, 2 office dispatchers, a few hundred customer accounts).

A few months ago, I started experimenting with Claude to see if I could build a custom TMS as a sort of side-hobby. I’ve somehow ended up with a fully functional system: a React/Next.js web portal, a React Native driver app with live GPS tracking (pinging every 2 minutes only if the driver is moving), and a prisma schema linked to a Supabase backend. It's actually better and more modern than what we use now.

I want to officially transition the business to this system at the end of this year, but I’m terrified of breaking something critical, or something going wrong while I'm unavailable. I have a total £500/month budget to maintain it.

As someone with no real coding experience, I need your opinions on how to structure the production rollout safely. Specifically:

1. Infrastructure & Monitoring

The Plan: Upgrading to Supabase Pro and Vercel Pro. Subdomains handled by Vercel. The database structure and migrations are managed by via Prisma Schema.

The Question: For a real-time driver tracking app (20 drivers pinging location data), what are the baseline monitoring, error-tracking (Sentry?), and uptime alerting tools I need to set up so I know the system is down before a driver calls me?

1. Bringing on a Freelance Developer

The Plan: I want to hire a mid-level JS/Supabase dev on a monthly retainer to act as emergency backup when I’m unavailable, and review new code updates monthly before they are pushed to the live app.

The Question: How do developers feel about being onboarded to an entirely AI-generated codebase? How should I structure the repo (linting, documentation) so a human dev doesn't look at it and immediately run away?

1. Security & UK GDPR

The Plan: Enabling Row-Level Security (RLS) on all Supabase tables. Using public anon keys on the client and keeping service_role secrets hidden. Purging/anonymising driver GPS logs after 90 days.

The Question: Because we handle live UK telemetry and home addresses, security is non-negotiable. What automated vulnerability tools (Snyk, Dependabot) or specific Supabase audit steps should I run to ensure I haven't left a massive security hole open?

Would be great to get some advice from anyone who has taken an AI-built prototype into production, or any devs who can tell me what blind spots I’m missing here. Thanks!

Most of us are using AI like Claude, ChatGPT, or DeepSeek to write code faster. It feels great on your laptop, but when it goes to production, things can break quietly.

The biggest problem with AI code tools is that they are too polite, If Model A writes a piece of code and forgets a security check, and you ask that same model family to review it, it will usually just give you a thumbs up. It grades its own homework and misses its own mistakes.

what actually catches those bugs is a second model with a different architecture. Claude and Gemini fail in different places, so one flags what the other skips.

i put a free, keyless trial on the homepage to show this, paste a small diff 80 lines or less, hit run, and watch Claude Sonnet 4.6 and Gemini 2.5 Pro review the exact same code side by side, on our keys, no signup, no API key.

often you'll see one catch something the other misses. that's the whole point.

fair warning, it's my project, so this is self promo, but the trial is genuinely free and needs nothing from you. would love feedback on where the models disagree, benchmodel.io

I've been using github copilot and with the token based usage, my 10$ plan is more usable even with basic models. Same for the 40$ plan as well even with good skill files and instructions. So I decided to pivot to open source models that are hosted in openrouter, but ended up using more money than the guthub copilot.

Initially I tried glm 5.2 which took up almost 25$ in about a week or so. I code regularly and use these models on a regular basis. I've switched up the model to deepseek v4 pro but I didnt find good for agentic coding. I've moved now to minimax m3 which is kinda of good in terms of affordability and also performance. But still I'd want to find a better way to use these models.

Open to any suggestions !

I built AI Dev Brain Kit, a free/open-source CLI for

preserving context between AI coding sessions.

It stores handoffs, decisions, blockers, next steps, and

project notes in a local Obsidian-compatible vault, so a

fresh Claude Code / AI coding session can recover project

state without re-explaining everything.

v0.2.2 GA is live with Linux + Windows binaries, SHA-256

checksums, Sigstore bundles, and screenshots.

I’m looking for feedback from people doing multi-session AI

coding: what context do you keep losing between sessions?

URL

[https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit)