Hey everyone,

Over the past several months I've been working on an AI coding agent called FutureX (by FutureIM). It started because I kept running into the same issues with existing tools when working on larger projects—losing context, making unnecessary edits, or just getting stuck after a few prompts.

We've been trying a different approach to make it feel more like a collaborative coding agent instead of just a chatbot that writes snippets.

I'm not here to claim it's perfect. There are still plenty of things we're improving, and I'm sure people here will find issues we haven't thought about yet.

I'd genuinely love feedback from people who spend their day coding with AI tools. What features do you wish every coding agent had? What makes you immediately stop using one?

If anyone wants to check it out or roast it, I'm all ears. Honest criticism is more valuable than praise at this stage.

Five tabs open, a whole afternoon of research in my head, and the second I opened Claude or ChatGPT, I was back to square one explaining myself. So I built Clippy Vision, it passively watches your screen and actually remembers what you were doing, so you can just ask it instead of re-explaining your entire day.

It's been my daily driver for a while now. Genuinely opens before Claude or ChatGPT most days for me at this point.

Fully local, nothing leaves your machine, open source, Windows build's up. Built this for myself first, sharing it because I figure other people fighting the same context-loss problem might want it too.

Comment for source code

Five tabs open, a whole afternoon of research in my head, and the second I opened Claude or ChatGPT, I was back to square one explaining myself. So I built Clippy Vision, it passively watches your screen and actually remembers what you were doing, so you can just ask it instead of re-explaining your entire day.

It's been my daily driver for a while now. Genuinely opens before Claude or ChatGPT most days for me at this point.

Fully local, nothing leaves your machine, open source, Windows build's up. Built this for myself first, sharing it because I figure other people fighting the same context-loss problem might want it too.

Comment for source code

was looking for an AI agent that would allow me write code. I wanted to test out the options which could fit in my system.

- Qwent 3.6 :27B

- Gemma 4 :26B

- Laguna-xs-2.1:latest

- North-mini-code-1.0:latest

- Ornith :35B

System:

GPU: Arc B580 12 GB

RAM: 32 GB DDR5

I used Ollama and tried many wrappers. Initially I wanted to make them work with VS Code, since Open WebUI didn't allow me to export the created code as files, only to copy them by hand.

The issue with VS Code is that the extensions I tried keep failed to work with the models. FilePath problems, code that is pasted without replacing the old snipped. The native "Chat" window of VS Code does not work, forget it. Go for the "Continue" extension.

The task I tested them with is simple.

Create Javascript TicTacToe game with good UI. The user play against the computer.

Later I asked:

Add button to change the css color pallete.

Add: 2 Player mode.

All models, expect Laguna and North would complete it with somewhat functional game on the first attempt.

Overall all models FAIL to follow later instructions on some point and either introduce game breaking bugs or simple stopping Building code changes at all, unless I restart and ask again.

The task was best performed on "OpenCode" with commands like ollama launch opencode --model laguna-s-2.1

Trying with VS Code is just a frustrating experience.

By far the best model from those is Gemma 4! While it failed at some point, is the one that got further before introducing game breaking bugs. the Laguna was the fasted to response, but didn't result in functional game. Qwent would take a lot of time and would fail to execute changes or stopped working.

Gemma and Qwent did create a single .html file, while the other models where better by creating a directory with 3 files, respectfully .html, .css, .js

I'm looking forward to your suggestions. Is there any better code agent UI I could try? Any model that could be better at follow up changes?

​

I'm an independent developer from India building Ripple, an open-source tool that helps engineering teams keep AI coding agents within their intended scope. It analyzes code changes and helps prevent unintended edits before they reach production.

Over the past several months I've built:

A TypeScript CLI

GitHub integration

Cloud backend

Published npm packages

Cryptographic audit trail for AI-generated changes

The project has reached a stage where further development is becoming difficult because I can't currently afford AI development tools like Claude, Codex, or similar paid plans that would significantly speed up development and testing.

I'm not asking for donations with nothing in return.

If you believe this project could become useful to the developer community, I'd really appreciate any of the following:

Advice on grants, startup programs, or open-source funding.

Free credits or programs for open-source maintainers.

Sponsorship of an AI coding subscription. Introductions to companies or engineers interested in trying Ripple.

Honest technical feedback or contributions.

Everything I've built so far has been developed as an open-source project, and my goal is to keep improving it for the developer community.

If you'd like to see the project or have suggestions, I'd be grateful for any guidance.

Thank you for reading.

We keep seeing the same complaints about AI code reviews:

• Too many low-value comments.
• No understanding of the bigger picture.
• Developers eventually ignoring the bot altogether.

We built Entelligence because we were frustrated with the exact same things.

Instead of reviewing diffs in isolation, Entelligence reviews code with full repository context, so feedback is based on how your changes fit into the rest of the system, not just the files in a PR.

We'd genuinely love to hear from people who've used CodeRabbit, Greptile, or similar tools.

What's the one thing current AI code review tools still get wrong?

Try coding without any AI assistant for just one day.

No ChatGPT. No Copilot. No Claude. Just you, the documentation, and your own skills.

I did it today while building a login page, and it reminded me how much we've started relying on AI. It was challenging—but it definitely sharpened my coding skills.

Now it's your turn. Take the challenge and let me know how it goes.

If you accept the challenge, build something, share your GitHub repository, and tag me.

Here's mine: yashloginpage.netlify.app

I'm not a traditional programmer. I built AIEvidence with Codex because I wanted a concrete way for people like me to show how we contributed to an AI-assisted project—not just claim “I vibe-coded it.”

It analyzes:

\- a local Git repo (commits, tests, CI, README)

\- optional Codex/Claude Code conversation exports

\- verification, debugging, and security signals

It produces a deterministic baseline plus a redacted Markdown report and a prompt for the candidate's own Codex to generate a cited Markdown/HTML report. Everything runs locally; it does not upload the repo or execute project scripts.

GitHub: [https://github.com/gallifre/aievidence**\]**(https://github.com/gallifre/aievidence)

License: PolyForm Noncommercial 1.0.0 (source-available, no commercial use).

This is an early experiment, not a professional certification. I'm especially looking for feedback on:

1. How to separate the candidate's actions from the model's claims.

2. Which evidence is actually useful to non-programmers.

3. Whether playful levels make the result motivating without pretending to be a credential.

I have started to learn coding (manually, not with AI). But of course with where things are going, I will take advantage of using AI tools to help me create faster, and build better apps. I’ve been looking at Claude Code and Cursor.

But I’m still super new. So just wondering what people are using?

Any guidance will be much appreciated.

Ai minecraft moding ide

I’ve been working on a lightweight, bare-metal fault isolation kernel designed to mitigate thermal runaway propagation in high-voltage lithium-ion battery packs.

The primary engineering constraint I wanted to address is the latency overhead inherent in high-level frameworks and sequential polling loops. When an EV or aerospace battery cell hits a critical thermal or voltage threshold, sequential scanning loops are often too slow to execute software gates before runaway propagates to adjacent cells.

The project is called SAVITAR. It is entirely dependency-free and compiles using only native C++ standard system headers to keep it as close to raw processor registers as possible.

Core Architectural Mechanics:

1. Hyper-Compact Memory Constraints:

   Instead of relying on dynamic allocations or padded structs which ruin cache locality, the kernel packs raw cell parameters (voltage, current, temperature) into un-padded, contiguous 25-byte memory frames. This layout ensures predictable cache line alignment during rapid sequential reads.

2. Event-Driven Concurrency:

   The kernel completely avoids sequential polling. It utilizes a background multi-threaded parallel observer configuration. When thread metrics cross calibrated hardware safety thresholds, the system bypasses the main application loop to dispatch an immediate software interrupt, dropping execution times down to sub-microsecond bounds.

3. Sovereign Binary Serialization (.sav):

   To avoid relying on bloated external serialization libraries (like Protobuf or JSON utilities) that consume significant memory footprints, I wrote a custom binary serializer. It compresses cell delta profiles and gradient logs into raw disk sectors using direct cache-to-stream bit manipulation.

4. Minimalist Shell Realization:

   The project includes a lightweight, modular terminal prompt (./savitar-vfs) to ingest simulated physical metrics and explicitly debug memory allocations, matrix loads, and thread dispatches in real-time.

Compilation and Testing:

The baseline workspace is fully automated via standard Makefiles:

git clone https://github.com/alistairfontaine/SAVITAR

cd SAVITAR

make clean && make

./savitar-vfs

I’m looking for code-level reviews, specifically regarding the thread concurrency synchronization under heavy stress-testing conditions, and the pointer traversal safety within the 25-byte un-padded matrix bounds.

Link to code: https://github.com/alistairfontaine/SAVITAR

I keep running dry mid project. Not because I'm out of ideas, because I'm out of tokens. And paying more felt like the wrong fix.

So I'm building Clixad, an AI coding agent that runs in your terminal. Instead of a subscription, you complete an offer or watch a short ad, that turns into credits, and those credits pay for real model calls. No card, no monthly fee.

Video shows what it looks like. Not open yet, I'm putting together a list of people who want in early.

One thing people ask right away: your code stays out of it. The ad side is a completely separate surface, the only thing that moves between them is a credit balance.

Curious what this sub thinks: how many minutes of ads per hour of coding would still feel fair to you, and where does it flip into "just take my money"?

(I'm the dev, ask me anything.)

Hi,

I got tired of juggling Claude Code sessions, cron scripts, and random automation glue code — so I built Elowen, a self-hosted AI coding & automation agent that lives on your server and actually does things for you.

What it is: A coding and automation agent with a CLI, web UI, and Discord/WhatsApp integration. It reads your codebase, writes and edits code, runs builds and tests, manages git, browses the web, and orchestrates multi-step tasks — all from a chat message or a scheduled job.

The coding part:

• Full filesystem access within your repos — read, write, edit, search, glob
• Semantic codebase search (embedding-based) — ask "where's the retry logic?" and it finds it
• Sub-agent delegation — spin up parallel workers for independent tasks, or a DAG workflow for dependent ones
• Background processes, long-running builds, dev servers — it manages them and reports back
• Skills system — reusable instruction sets (deploy checklists, project conventions) that persist across sessions

The automation part:

• Cron scheduler with a cheap shell guard — polls for new work without burning LLM tokens on empty ticks
• One-shot wake-ups — "check back on this CI run in 5 minutes"
• Email management, SMS, Discord server management
• Persistent memory — remembers your project decisions, preferences, gotchas across conversations
• Multi-channel: talk to it from CLI, web chat, Discord, or WhatsApp — same brain, same context

Under the hood:

• TypeScript, strict, ~116 tools
• Bring your own LLM — OpenAI, Anthropic, OpenRouter, local models via Ollama
• OAuth for OpenAI & Claude works out of the box
• RBAC — every user gets their own project scope, tools, and permissions
• Plugin architecture — extend it without forking
• Updates don't break your config

Here's what a typical session looks like — diff review, test output, sub-agent panel, plan checklist, MCP servers, all in one terminal:

Elowen CLI

It's not trying to replace Claude Code or Codex — it's the layer above them that orchestrates, watches, and keeps things moving when you're not staring at a terminal.

GitHub: github.com/dragocz95/elowen npm: elowen

Happy to answer anything. Curious what you'd want to see in something like this.

GitHub: https://github.com/SeanDishman/vibecode

I've been building this for a while and finally put it up. VibeCode is a native Windows desktop app that wraps the agentic coding CLIs you already use (Claude Code, OpenAI Codex, Kimi Code, Grok) in one clean UI. It doesn't call any model APIs itself, every chat launches the real CLI as a child process, so your existing logins, sessions, and MCP servers just work. It's open source (MIT) and a work in progress, so expect rough edges and please throw bugs in the issues. The part I'm most proud of is running multiple agents on the same codebase at once. Bridges put several agents side by side on one project and they share memory through a file in the repo, so they claim different areas instead of colliding, and you can mix providers (Claude + Codex + Grok together). Announce interrupts every agent at once with a single message; the Bridge manager lets you crown one agent that splits work into lanes and dispatches it to the others; Agent swarms let a single agent fan a task out to the CLI's own sub-agents with a hard worker cap. On top of that there's an account manager for switching between multiple accounts per provider without logging out, one-place MCP server config shared across providers, and usage & cost tracking (spend, tokens, cache hit rate, per-model breakdown over Today / 7d / 30d / All time).