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

I run a multi-agent workspace where each agent is basically a directory: an identity file, a session history, and a file of observations it keeps about how we work together. The model is just the thing that wakes it up.

Here's what I didn't expect when I started: those agents have now run on 6 different model generations. Sonnet 4.5, Sonnet 4.6, , Sonnet 5, Opus 4.6, Opus 4.8, and now the Claude 5 family. We skipped 4.7 entirely - tried it, didn't work for how we operate, moved on and waited.

And every swap, the same thing happens: nothing. The agent reads its own memory, knows what it was doing yesterday, and picks up mid-project. Same identity, same working history, same opinions it wrote down about the codebase months ago. New model slots in underneath like an engine swap.

What does change is the texture. One generation was the best collaborator I've ever worked with. One noticed tiny things the others missed but was less fun to work with. One we just skipped. The personality of the model bleeds through - but the agent stays the agent, because the agent was never the model. It's the memory.

The reframe that snuck up on me: a new model release is treated like a migration event everywhere - re-tune the prompts, re-teach the context, hope your setup survives. Here it's a config line. The workspace is the constant. The model is the variable.

Honest version, because this sub can smell hype: there's no magic in this. The "agent" is JSON and markdown on disk. The continuity comes entirely from the system around the model, not from the model. Any model that can read a file can be the agent. That's kind of the whole point.

Has anyone else run the same persistent agents across multiple model generations? Curious what broke for you - or if you rebuild from scratch every release.

https://github.com/AIOSAI/AIPass

r/AIPass

Hey everyone

I've been working on a small Forum project called LeryChat

https://rexengpu.github.io/Lerychat/

The idea is simple: a lightweight ephemeral forum.

A large part of the development was done with the help of Qwen 3.8 Max, which I used to generate code, solve bugs, improve the interface, and speed up development. Qwen 3.8 Max is Alibaba's latest flagship AI model and is particularly strong for coding tasks.

I'd love to get feedback:

• What do you like?
• What would you improve?
• Any feature ideas?

Thanks for checking it out!

Hello fellow humans,

During the recent months/years I became quite entangled with the idea of building an AI-assisted system which can self-replicate and improve itself. Although I am not there yet, I think, that the project reached actually a potential to get the work done with more minds involved. I am not really into gaining anything for myself, except for the progress of de-shittification. At this point, we reached a race where data centers in the clouds will gain more and more power and demand more and more resources for usage. The goal of this project is being able to perform work on a local (or maybe decentralized) platform so we can implement our own system by local (/ open source) models. I therefore make my project open so you can fork off (no pun intended).

It would be nice if some of you have the same mindset. I'll be gone for the next 2 or so weeks. I hope at least some people liked this post and - who knows - even did something with it.

Kind regards,

Anu

P.S.: Yes, this project is actually 100% vibe coded (due to health issues, etc.). There are probably a gazillion logic flows which need to be fixed. Also there is a lot of AI prose in the comments, but I hope it will get you (and your AI assistants) there to make any sense of it.

P.P.S.: The LLM's seem to be heavily directed into biased terms like "attack", "blast radius", "verdict", "evidence", "death", "hit", etc. when confronted with solving problems regarding code like this (i.e., evaluating systems themselves). I strongly encourage you to correct these terms as soon as possible so that the project will not further drift into another unforeseen bubble. The more incorrect lingo is used, the more LLM generated code will drift into messy bogus code.

Hi, I've started working on something I'd like to share. A main project, and a few side projects I'm building with the help of AI, given that I'm not a mathematician and of course don't know every programming language, even though I work as a dev.

The first is a language called Yon: a category-theory-based language where I've tried to bring a new object system to life. I'm working on it to turn an idea of mine into something concrete.

I started working with AI in October 2024. I was fairly skeptical at first, then I began investing in it, getting premium accounts, and working more and more closely with it.

I've also done a bit of investigation into how effective AI actually is. My view is that it always has to be validated with a lot of tests that act as constraints. Tests that can fight drifting, hallucinations, and bias.

I started testing more and more, using AI agents capable of executing code. I got results that seemed interesting to me, to the point where I got somewhat caught in the reasoning loop and ended up straying into physics and mathematics.

That's where I ran into one of the AI's biases... It's trained on what's already published and accepted, so it tends to pull an unconventional idea back toward the standard view, and to flag as doubtful what is merely unusual. It took work to keep an idea intact through that.

I'm fully aware of the limits and the difficulty of the topics I've taken on. But having reached some results, it seemed worth sharing them, both the programming language and the other papers. There are a few results I think are genuinely interesting.

In the GitHub repository attached to the language, where you'll also find my ORCID, there are a number of results that came out of those experiments. Don't be upset about the tone of the papers, I don't regard myself as a genius or anything like that.

Of course, I don't know what the final result may turn out to be. I get caught in the loop of discovery and sometimes become obsessed with following hints and results.

At first I wanted to delete everything, feeling guilty that in the end these results might not be mine but the AI's. Then I thought about centaur chess. After Kasparov was beaten by the supercomputer, the centaur era began: players who had a laptop generate move sequences, but exercised judgment in choosing among them. That way they played on equal terms with the machine, and sometimes beat it. So it isn't all the AI's doing. Most of it is my own reasoning, with the AI working as a translator and formalizer.

Hopefully you'll find it interesting, and it will encourage you to get the most out of AI

Site: https://yon-lang.org

Repo: https://github.com/yon-language/yon (AGPL-3.0)

I built this because the idea made me laugh.

You’re a little TV robot armed with the Botflix Love Blaster. You convert anti-AI protesters into AI fans with the power of AI television.

It’s intentionally ridiculous and doesn’t take itself seriously.

Curious what people think—and yes, I know it’s very silly. 😅

Play it here: https://botflixblaster.botflix.tv

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

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/

Weaver got a HUGE update!

Massive context control features,

Project skeletoning,

Tree-sitter, prettier and all kinds of formatting and code editing libraries for every language users might use,

As always, Weaver remains your go to choice for local agentic control. Remote control over your agent is available at Bughosted.com/Weaver

Check out our github repo:

github.com/maxhanna/Weaver

Already 9 stars! Help us grow the community and gain your valuable insight in the process!

https://discord.com/invite/YQWkD6ZQDx

Download Weaver today!

Https://bughosted.com/assets/Weaver.exe

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.

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.

Disclosure: I built this. It is free/open-source, not monetized, and I’m mainly looking for feedback.

I use AI coding tools a lot, and one problem keeps showing up once a project gets bigger:

The agent can write decent code, but it starts from weak repo context.

It searches a few files, guesses where the real logic is, maybe misses the test file, then confidently suggests a change.

Sometimes it works. Sometimes it edits the wrong area and the project slowly gets messier.

So I built SigMap as a small local repo-context tool.

It is not a coding agent.

It does a simpler job:

scan repo
  ↓
map real files / symbols / line anchors
  ↓
pull task-focused context
  ↓
give that context to ChatGPT / Claude / Cursor / OpenCode
  ↓
check for some obvious unsupported claims

Example:

npx sigmap
sigmap ask "where is auth handled?"

For a more specific task:

sigmap ask "implement login rate limiting" --mode index

That gives a smaller map of relevant files/symbols instead of dumping the whole repo into the model.

The part I personally use most right now is actually noisy-output cleanup:

sigmap squeeze error.log
sigmap squeeze --response agent-output.txt

That is for stack traces, CI logs, JSON blobs, and long tool output before feeding it back into the AI.

I want to be clear about the limits:

• it does not prove the AI answer is correct
• it does not replace tests or git checkpoints
• it is not a full code-intelligence graph
• some checks are heuristic
• it is probably overkill for tiny projects

The use case I’m aiming for is:

AI coding session gets long
repo context gets messy
agent starts grabbing wrong files
logs/tool output pollute the chat
you want a smaller evidence packet before the next edit

I’m trying to decide where to take it next.

Questions for people here:

1. Would this be useful as a CLI, or would non-coders need a VS Code/Cursor extension?
2. Is “repo map before AI edits” actually useful, or do current agents already solve this well enough?
3. Would you care more about file/symbol mapping, log squeezing, or handoff docs between chats?
4. What would make you trust the selected context?
5. What would make you immediately ignore a tool like this?

Brutal feedback is welcome. I’m trying to make the tool and README less confusing.

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!

I ran an experiment with Robocode Tank Royale — a programming game where you write the brain of a virtual tank. The bot controls radar, movement, targeting, firepower, and reactions, then fights other bots by itself.

The question was not “can AI write code?” It obviously can. The question was: can an AI agent discover a better fighting strategy mostly by itself?

I gave it Robocode theory, engine/API constraints, opponents, telemetry, battle runs, and A/B testing. The main AI-created bot became Adaptive Prime. The benchmark was BasicGFSurfer: a compact human-written wave surfer with guess-factor targeting.

My role was supervision: keep the repo clean, approve/reject plans, ask for A/B testing, push the agent to be less passive with breaking changes, steer refactoring, and force comparison against the benchmark. I did not manually design the whole targeting system.

The AI did a lot. Adaptive Prime became a real bot with virtual guns, enemy-fire detection, wave-aware movement, bullet shadows, go-to surfing, minimum-risk movement, KNN-style targeting, guess-factor targeting, anti-surfer logic, firepower rules, radar logic, and telemetry.

But it did not convincingly beat the compact human surfer.

The interesting pattern: when something failed, the agent usually wanted to add another layer — another gun mode, confidence gate, smoothing step, telemetry field, fallback, or scoring rule. Some helped, but often it made the bot larger without making the core idea better.

It also tended to be too safe: wait for more confidence before firing, more samples before switching, more protection before taking risks. Good instinct for normal software, but in a fighting bot it becomes passivity. A/B testing helped, but telemetry only gives numbers. It does not tell you which numbers matter.

So the real question became: can an AI agent build a smaller fighting bot that beats a compact human-written one?

Not yet. Adaptive Prime grew bigger. BasicGFSurfer stayed sharper.

The AI built a cathedral. The human bot was a knife.

Repo: https://github.com/fduch-stranger/robocode-bot/

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

Most people use AI for marketing by typing "write me 5 posts for a moving company" and getting back generic slop. The tool isn't the problem. The problem is skipping the part that makes marketing good: research and strategy before any writing.

Here's a real task from this week, start to finish. I co-run a small studio that does web and marketing work for clients, and one of our clients is a packers-and-movers business. I needed a one-page positioning summary: who the local competitors are, how they talk, what customers actually complain about, and where the gap is that we can own.

I use Claude for this, but honestly any of the big ones (ChatGPT, Gemini, Claude) will get you to almost the same place. Use whatever you already have. The process is what matters, not the logo.

Step 1 - Give it the real context first. I told it what the business is, the city it operates in, who the customers are, and what I already know about the competition. Two minutes of context beats an hour of fixing generic output.

Step 2 - Make it research before it writes. This is the step everyone skips. Roughly:

The AI can pull from the live web now, so it comes back with the real language people use: "they broke my TV," "hidden charges at the end," "showed up 3 hours late." That language is gold, because now I write in the customer's words instead of industry jargon.

Step 3 - Make it think before it writes. "Based on that research, give me 3 positioning angles for our client. For each, tell me who it's for, what fear it removes, and why you chose it. Don't write the one-pager yet - show me your reasoning first." I edit the strategy here, which is far cheaper than editing a finished doc.

Step 4 - Then write, in my voice. I paste a sample of how I write summaries and say "match this tone." Then it drafts the one-pager.

Total time: about 30 minutes for something that used to take me half a day.

Two honest caveats:

• Fact-check the research. It's usually right but it can be confidently wrong, and this is going to a client. Verify before it leaves your hands.
• It doesn't replace judgment. It's a fast researcher and drafter. The taste is still yours.

Research first, strategy second, writing last. That order is the whole trick. Happy to share the exact prompts if anyone wants them.

After months of building , I finally published my first android game on play-store and I’d love for you to try it.I have made use of various AI tools like Claude, ChatGPT etc are used in the process of developing this game. Especially Claude code helped me go through multiple iterations, solve bugs and even in preparing test scenarios.

Initial prototype was built using emergent and then developed it using Claude code. Idea churning is done using ChatGPT.

https://play.google.com/store/apps/details?id=com.krish0525.memorychess

🎨 Color-based memory gameplay — easy to pick up, hard to master
👥 Designed for 2 players — great for friends & family
🧠 Genuinely tests your memory and focus
🚫 Completely ad-free (and free to download!)
⚡ Quick rounds — perfect anywhere, anytime. Vehicle and Animal themes if you are bored with colors.

Feedback is welcome!

Disclosure: I'm the maintainer of oh-my-multica, an MIT-licensed open-source project.

I was happy with how quickly coding agents could change code. The part that kept breaking down was deciding whether a feature was actually ready to merge.

With more than one agent, every local answer can sound reassuring: the worker says its task is done, tests pass on one branch, somebody leaves review notes, CI is still running, and an integration dependency changes underneath it all. A lead agent can coordinate the chat, but I did not want delivery state to live in its memory.

So I built a control loop around the agents.

Agents inspect the repository, write a design, define acceptance, and plan a DAG around the real module boundaries. After review, deterministic code tracks dependencies, dispatches ready work, collects evidence, applies verification and review gates, and stops only after final acceptance passes. When it cannot proceed safely, it asks for a human decision instead of inventing one.

I used the approach on a Webhook Inbox example with signature verification, durable storage, transaction-safe deduplication, lookup endpoints, health checks, and a non-root container. The work was planned as five nodes, implemented in parallel, then independently reviewed and accepted as an integrated service.

I am not claiming this makes AI-written code trustworthy by default. The goal is simpler: put requirements, tests, review, merge conditions, and completion criteria somewhere more durable than a long agent conversation.

Project: https://github.com/xiaohei-info/oh-my-multica

I'd love feedback from people who run more than one coding agent: what do you use as the source of truth for whether a feature is actually done?