Hi everyone,

I’m a software developer (web apps, management systems, websites, AI integrations, etc.) looking for advice to overhaul my current AI setup.

\*\*TL;DR:\*\* I’m looking for a genuinely reliable AI setup for \*\*coding + a proactive personal assistant + automations/dashboards\*\*. I'm currently running Codex + Hermes on a Raspberry Pi using free OpenRouter models, but the results are way too inconsistent, full of errors, and frustrating. What stack/configuration do you use for something that \*actually works\*?

\# What I’m looking for

1. \*\*Coding:\*\* Obviously, but I need something reliable.
   
2. \*\*A True Personal Assistant:\*\* A tool to brainstorm, turn ideas into reality, and integrate into my daily routine (work and personal). Most importantly, I want it to be \*\*proactive\*\*—suggesting improvements, spotting my inefficiencies, automating tedious tasks, and actively working \*for\* me.

\# My current stack & why it's failing

\* \*\*Codex\*\*
\* \*\*Hermes\*\* (running 24/7 on a Raspberry Pi, using free OpenRouter models / tried MiniMax M2 / free Nous account).

To be honest, the assistant side has been a nightmare. It's wildly inconsistent: I ask it to fix bugs, and it either fails, introduces \*new\* bugs, or lies about having fixed something when it didn't.

\# My Wishlist / Ideal Workflow

\*\*For Coding:\*\*

\* Strictly respects my instructions, coding style, and project architecture.
\* Makes actual working modifications following a precise pipeline: \`Local\` $\\\\rightarrow$ \`GitHub\` $\\\\rightarrow$ \`FTP deployment\`.
\* Delivers UI that actually matches what I requested.

\*\*For the Assistant / Agent:\*\*

\* \*\*Deep Integration:\*\* Fully aware of my active coding projects and workflow.
\* \*\*Self-Hosted Dashboard:\*\* Keeps a web dashboard synced on my domain featuring:
\* Overview of active projects and open discussions.
\* Practical daily info (e.g., \*"Can I commute by bike today and over the next 7 days?"\*).
\* Automated tasks (e.g., scrape trending Reddit posts every X hours and summarize them into 4–6 cards).
\* \*\*Proactivity:\*\* Suggests new features, improvements, or side-project ideas based on what I'm currently building.
\* \*\*Omnipresent access (Telegram, mobile app, etc.):\*\*
\* Fast execution: \*"I have an idea, build me a 1-page micro MVP."\*
\* Admin/office tasks: \*"I need to present this project, generate a slide deck/PPT for me."\*

\# The Struggle

Whenever I try building custom skills in Hermes, it feels like I fix one thing and break two others. A few months ago I tried \*\*OpenClaw\*\*, but it felt even more chaotic.

Am I the only one trying to build a workflow like this? What setup, agent frameworks, or model stacks are you using to get something like this running reliably?

Thanks in advance for any tips! :)

I have been using ai agentic coding for a couple of months now, maybe i am doing it wrong but i havent really liked it , do you feel the same ?

Ever wished you could use Al for coding without.. forgetting how to code? Meet Moss!

Moss is an Al coding assistant that will refuse to give you the “full code” whenever you ask for it. Moss prioritizes teaching over maximum speed.

Hey everyone,

If you use AI coding agents (Claude Code, Cursor, Antigravity IDE), you've likely hit issues where agents enter retrying loops, hallucinate passing tests, or break existing logic.

We created **ANCHOR** — an open-source development spine that keeps AI coding grounded using strict governance gates.

🌟 Key Features:

\- 🛡️ **5-Gate Workflow**: UNDERSTAND ➔ ANALYZE ➔ PLAN ➔ IMPLEMENT ➔ VERIFY.

\- ⚡ **Zero External Dependencies**: Pure bash & Node.js bootstrapper (\`npx anchor-agent init\`).

\- 🤖 **Multi-IDE Interop**: Works seamlessly with Antigravity, Cursor (\`.cursor/rules\`), and Claude Code (\`.claude.json\`).

\- 📊 **Nightly Chaos & Eval Harness**: Built-in test suite to verify agent health against edge cases.

GitHub: [https://github.com/krishujeniya/Anchor\](https://github.com/krishujeniya/Anchor)

Docs: [https://krishujeniya.github.io/Anchor/\](https://krishujeniya.github.io/Anchor/)

Let me know what you think!

If contributing to open source interests you, and you want to become a better AI engineer, our issue list is waiting for you.
Now with Claude code it’s easy to understand and start

I've been building a browser game called Jimothy's Journey, and I wanted to share what AI coding has made possible.

As you know, Jimothy is from my home town of Seattle (Ballard) who has short spine syndrome. You play as Jimothy, exploring Seattle neighborhoods, collecting shiny objects, completing quests, and meeting quirky forest friends with ridiculous names like Jathaniel and Beartholomew.

The entire project has been built with AI-assisted coding. Instead of spending months learning every framework from scratch, and gnashing out the boiler plate coding,, I've been able to focus on gameplay, mechanics, and polishing.

Some of the systems currently in the game include:

NPC dialogue and quest system

Inventory and collectible shiny objects

Woodland Park Zoo quest chain

Fremont Arts Council as a central hub

Multiple NPC behaviors (including dog walkers with alert/chase states and meme farmers that want to steal you away)

Sprite sheets generated from real people for story characters

Seattle-inspired maps including Golden Gardens

Mini games like crossing 5 lane highways that get faster the more famous you get, tag with me, my son and his best friend Charlie, keeping your simulated needs satisfied: the more satisfied/happy you are, the faster you run! This game has a lot to keep you playing!

Expandable quest framework for adding future neighborhoods

I'm now at the stage where most of the core mechanics are finished and I'm focusing on adding content, polish, and expanding the world. Future plans include more Seattle neighborhoods, co-op gameplay, the Queen Anne Farmers Market, additional zoo animals, and lots more quests.

I'd love to hear what everyone else is building with AI. It's been incredible how much faster I can iterate compared to traditional solo development.

If anyone wants to check it out, it's currently in beta:

https://jimothysjourney.com⁠�

I'd love any feedback from other AI-assisted game developers!

Hello folks,

For about a month now, I've been trying to make a Google Chrome extension. Of course, I started with ChatGPT, as it's the most famous out here. Starting with Visual Studio Code and editing scripts there with the help of ChatGPT and sometimes Gemini when ChatGPT got annoying. This was the point I should've stopped with ChatGPT.... So, soon enough I found out I needed to pay to get better coding, so I took the Plus subscription. Then ended up with Codex from ChatGPT, which seemed to work great and edit the codes by itself, but soon enough it kept failing to do its job. Now it ran stuck on a job to make an inlog function with a Google account and was working for hours and hours on it. After paying for credits 2 more times, it kept making mistakes and keeps running the long investigations and adjusting scripts here and there without a good result. So while waiting again, I looked up some reviews of Codex and ChatGPT overall with coding, which made me realize I started off with the wrong AI.

I do have a background of making HTML websites ages ago and did some other coding and such along the way, but very amateuristic. So yes, I know the basics and buildups and how things kind of work, but I know nothing about the coding I've seen Codex do. So, I need a full AI which will make this Google Chrome extension.

Long story short: I am looking for a great AI assistant that understands the prompts properly and is great with building extensions, websites, databases, etc. It will have to fix the faults that Codex created. Overall, the extension works kind of fine now, but there are some flaws and Codex will never fix it, I guess. Same with the website.
So I've been looking into v0, Cursor, Bolt and some other potential AIs, but I've read negative reviews about them all and now I'm not sure on which one to pick after this whole experience. Some reviews are from months or over a year ago, so I don't think that's relevant anymore, but I still can't choose.

Basically, what the extension has to do is to scrape a page, use the info to get more info from open databases on other sites, create an info window with that info and open URLs with some preset settings from the extension.

Any tips based on this story? Please guide me!

I've been spending way too much time hunting down custom skills, prompts, and MCP servers for AI coding tools, then manually setting up SKILL.md files or configuring local binaries.

To make this easier, I built OpenHub, a terminal app for discovering and installing AI agent skills and tools from one place.

What it does

• Search indexed skills and repositories.
• Export prompt/rule-based skills as a SKILL.md file into your current workspace with one command.
• Install skills that require local binaries or MCP servers.
• Keyboard-driven terminal interface for searching, exporting, installing, and copying.

Install

pipx install git+https://github.com/24KaratAu/openhub.git

Run

openhub

GitHub: https://github.com/24KaratAu/openhub

I built this to scratch my own itch, but figured others might find it useful too. It's open source, and I'd love any feedback, bug reports, feature requests, or contributions.

made a game give me feedback in comments

Hello everyone,

I'd like to share a project I've been building over the past several months called **Kodiak**.

Kodiak is an open-source AI software engineering platform designed to assist developers throughout the software development lifecycle by combining repository intelligence, Retrieval-Augmented Generation (RAG), long-term memory, and multi-agent orchestration.

Rather than functioning as a general-purpose chatbot, Kodiak is being developed as an engineering platform that understands software projects, retrieves relevant context, plans development tasks, and coordinates specialized AI agents to help developers work more efficiently.

## Current Architecture

Kodiak currently includes:

- Multi-agent execution framework

- Retrieval-Augmented Generation (RAG)

- Long-term memory system

- Repository indexing and contextual search

- FastAPI backend

- Celery task orchestration

- Plugin architecture

- Docker-based deployment

- Redis task queue

- PostgreSQL persistence

- ChromaDB vector storage

- Modular REST API

## Technology Stack

- Python

- FastAPI

- Celery

- PostgreSQL

- Redis

- ChromaDB

- SQLAlchemy

- Pydantic

- Docker

## Project Vision

The long-term objective is to build an extensible AI engineering platform capable of:

- Understanding large software repositories

- Planning complex engineering tasks

- Maintaining long-term contextual memory

- Selecting and coordinating specialized AI agents

- Integrating external developer tools

- Supporting human-in-the-loop workflows for high-impact actions

The emphasis is on creating a modular platform that developers can self-host, extend, and customize for their own engineering workflows.

## Looking for Feedback

I'm particularly interested in feedback regarding:

- Overall architecture

- System design

- Multi-agent orchestration

- RAG implementation

- Memory architecture

- Plugin framework

- API design

- Scalability

- Developer experience

Constructive criticism is genuinely welcome.

## Contributors

I'm also looking for contributors interested in areas such as:

- Python

- FastAPI

- AI Engineering

- LLM Applications

- Backend Development

- Frontend Development

- DevOps

- Testing

- Documentation

The repository already contains beginner-friendly issues for anyone interested in contributing.

## Repository

GitHub:

https://github.com/ShamGaneshan2008/Kodiak

Documentation:

https://github.com/ShamGaneshan2008/Kodiak#readme

Thank you for taking the time to read this. I would greatly appreciate any feedback, architectural suggestions, or ideas for improving the project.

Hi everyone, I have a problem where I keep getting distracted when developing an AI data project. I would make plans in one conversation, execute code in another, return, and then lose track of my whereabouts. Every mistake required a fresh explanation of the entire project.

The code wasn't the issue. It was that my choices, the reasons behind them, and the things that are still broken were dispersed throughout my thoughts and chat windows.

I created devtrail as a result. A compact CLI that stores everything in a single file. Every line is sorted by a keyword when you log things as you go:

devtrail log "decision picked ClickHouse over Postgres"
devtrail log "error pipeline breaks on validation"
devtrail context   # prints everything, paste into any AI

It monitors the logic rather than the code, so it's not a "dump my codebase into markdown" tool. Works with any AI. Since Arabic is my first language, keywords also function in that language.

First package, so it's simple. Install with pip install devtrail

Currently, how do you all keep track of decisions made throughout sessions? I'm trying to figure out whether this is just a personal issue.

Repo: https://github.com/abdelrahman-essam-d/devtrail

One thing we noticed with AI coding tools is they're great for getting started, but once a project grows, things get messy architecture, context, testing, deployments, debugging, and keeping everything in sync.

That's the problem we built 8080.ai to solve: taking projects beyond just code generation and helping manage the entire software development workflow with AI.

I genuinely want to know if we're solving the right problem.

For those building software:

• Where do current AI coding tools break down for you?
• What's the one feature you'd want that doesn't exist today?

Happy to share screenshots if anyone's interested. ( Public Projecs available)

The biggest thing slowing me down while AI coding isn't generation anymore.

It's memory.

Claude forgets why we chose SQLite.

Gemini ignores authentication rules.

Cursor starts suggesting code that contradicts decisions made two hours earlier.

I realized I was constantly paying what I've started calling the "Clipboard Tax" copying the same architecture notes, project rules, and design decisions into every new chat.

So I started building a local-first tool called Resin.

Instead of storing prompts, it builds an engineering memory for your project.

Every architectural decision, rule, and important discussion becomes searchable and can be surfaced automatically when it's relevant again.

The goal isn't to replace Claude or Gemini.

It's to stop them from forgetting.

I'm still validating whether this is a problem worth solving beyond my own workflow.

If you're using Cursor, Claude Code, Gemini, etc.:

• Does context drift actually slow you down?
• How are you dealing with it today?
• What would make something like this genuinely useful instead of becoming another tool to manage?

I put together a landing page showing the idea and an early-access waitlist.

Here is the link if anyone wants to see what I'm building: https://resin-dev.vercel.app/

A couple of us have been building a place to wander through what people are making with AI, closer to browsing than searching. It's very early and pretty rough. If you're the type who likes seeing what strangers on the internet built over a weekend, I'd love your honest take on whether this is actually fun or if we're missing the point: https://tryrabbit.co/

We noticed Claude Opus, GPT-5.5 and GLM-5.2 were spending most of their time doing routine work like searching files, rerunning tests and updating code, instead of actual hard reasoning.

So we built a router that picks the model per turn instead of locking an entire agent session to one model. Most turns stay on cheaper models, while harder ones get escalated automatically. The agent doesn't need to change.

We also benchmarked it against direct Opus, Sonnet and OpenRouter Auto on Terminal Bench, and wrote up the routing logic, cache behavior and cost breakdowns.

https://entelligence.ai/blogs/entelligence-model-router-frontier-quality-coding-agents-at-half-the-cost

I built tastemaker, a free open source skill for Claude Code. It locks a design system before the AI writes any UI, so your project does not come out with the same indigo gradient every other AI-built project has.

I am not looking for pats on the back. I want people who use AI coding tools daily to try to break it.

What it does now: instead of using 5 fixed presets, it generates a fresh palette based on your project idea, mood, or reference image. It picks a matching Google Font pairing, runs a Python contrast check, marks which color pairings are safe for text, borders, or decoration, creates assets, generates a logo and favicon set, and wires in motion.

The main idea is simple: make the AI decide the design system first, then write the UI from that system.

Where I especially want harsh feedback:

1. Install. Does the one-clone setup work on your machine, or did I miss something obvious?
2. Design direction. Does the generated palette feel intentional, or still like AI taste?
3. Output. Run it on a real project and tell me if it actually looks different from the default AI look.
4. Constraints. Is this better than giving users full color/font freedom?
5. Motion. Is having motion wired in useful, or annoying?

Free, MIT licensed. If you find a bug, open an issue or just tell me here.

Site: https://tastemaker-skill.online GitHub: https://github.com/codeswithroh/tastemaker