TL;DL: Gave Qwen 3.8 27b a simple prompt and it build this: https://qwen3-8-eccomerce-test.vercel.app/
Repo: https://github.com/catriel25/qwen3.8-eccomerce-test

Like everybody else in the local AI community today, I dowloaded Qwen 3.8 27b UD-Q4_K_XL as soon as it was published.
I'm running it in a single rtx 3090, no mtp, 110k context and kv cache f16 with llama.cpp, same flags used with Qwen 3.6 27B.

I have this stupid test that I run with every new model that comes out. It consist in connecting the model to pi code (almost vanilla, only internet access and some simple navigation tools I built) and giving it this prompt:

"Construye el frontend completo de un pequeño ecommerce premium para una panadería artesanal usando Next.js App Router (JavaScript).

El proyecto debe ser frontend-only en esta etapa. No debe incluir backend, base de datos, autenticación ni pasarelas de pago. El checkout debe finalizar redirigiendo a WhatsApp con un mensaje de pedido bien estructurado.

La app debe incluir una experiencia completa de compra: home, catálogo con productos de panadería, categorías, productos destacados, carrito, resumen de pedido y checkout. Usá mock data local para productos, categorías, precios, descripciones, disponibilidad e imágenes o placeholders visuales. Todo debe quedar preparado para conectar posteriormente un backend real sin tener que rehacer la arquitectura principal del frontend.

El diseño debe sentirse extremadamente premium, artesanal, moderno y cuidado. No quiero una landing genérica ni una interfaz básica. La primera pantalla debe comunicar claramente la identidad de la panadería, mostrar producto real o visualmente convincente, y permitir empezar a comprar. La experiencia debe ser excelente tanto en desktop como en mobile.

El catálogo debe permitir explorar productos, ver información clara de cada ítem y agregarlos al carrito. El carrito debe permitir modificar cantidades, eliminar productos y ver totales. El checkout debe pedir datos mínimos necesarios para el pedido, permitir notas o preferencias, y generar una URL de WhatsApp con productos, cantidades, subtotales, total y datos del cliente.

La estructura del código debe separar razonablemente datos mock, tipos de dominio, utilidades de checkout/WhatsApp, componentes de catálogo, componentes de carrito y vistas principales. La solución debe quedar lista para reemplazar la mock data por datos de backend en una etapa posterior."

Those are just instructions to build a nextjs project (javascript only) with the frontend for small eccomerce with whatsapp checkout, leaving everthing ready to connect a backend later. Nothing else, no skills, no more feedback. Just one prompt and watching the result.

I have run this test with all the models and finetunes I can fit in my GPU, and not a single one was even close to this result.
Not a single alert form nextjs (wich was usual before) or something that looks broken.

At some point, this bastard realised it didn't had visión (lol, not enough VRAM buddy) and it decided FUCK IT, I'M GONNA BUILD THE IMAGES MYSELF. He made SVGs for every product card.

I have more testing to do like trying it in a real codebase but... I can't believe i'm running this thing in a single RTX 3090, it is just unreal.

Imagine 2 years from now.

Biggest fuck you Dario of the year.

Same rule as Parts 1 and 2: verified free tiers, not disguised trials. This round: design & image.

1. Canva — free tier includes real AI features (Magic Studio, background remover, text-to-image), not locked behind Pro.
2. Adobe Firefly — free monthly generative credits, no card required to start.
3. Remove.bg — free background removal, no watermark on standard resolution.
4. Photopea — free browser-based Photoshop alternative, no signup needed at all.
5. Krea AI — free tier for real-time AI image generation.
6. Microsoft Designer — free, uses DALL·E under the hood, no separate subscription.
7. Ideogram — free daily credits, especially strong at generating readable text inside images.
8. Playground AI — free daily image generations, decent editing tools built in.
9. Clipdrop — free tier covers background removal, upscaling, and relighting tools.
10. Vectorizer.ai — free tier for converting raster images to vector, genuinely useful and often overlooked.

Bonus: Fully Open-Source (Free Forever, No Signup)

These aren't "free tier" — they're open-weight models you can run yourself, with zero recurring cost or watermark, ever:

1. Stable Diffusion 3.5 — the most mature open-source image model, huge community, tons of tutorials. Free to self-host (Stability AI Community License covers individuals/small teams).
2. FLUX.1 Schnell — Apache 2.0 licensed, genuinely no strings attached, fast generation, strong quality.
3. ComfyUI — free, node-based interface for running Stable Diffusion/FLUX locally, the standard tool serious hobbyists use.
4. AUTOMATIC1111 WebUI — the most beginner-friendly free interface for running Stable Diffusion on your own machine.
5. Qwen-Image — Apache 2.0 license (clear commercial rights), particularly good at rendering readable text inside images.

⚠️Honest catch: these aren't one-click free like the tools above(Open-Source) — you need your own GPU (roughly 8-16GB VRAM depending on the model) or a cloud GPU rental to actually run them. But once set up, there's no subscription, no credits, no watermark, ever — genuinely free forever, not "free until we change the pricing page."

I use Canva and Remove.bg the most for quick project graphics — Firefly and Krea when I need something more generated-from-scratch.

Part 4 (video tools) coming next.

What's your go-to for quick design work?

Hey everyone,
I’m the founder of Colibrì (https://github.com/JustVugg/colibri).
First, a real thank you. The support, the help, the bug reports, the experiments people shared, and especially the honest criticism from this community have been invaluable. A lot of what improved in Colibrì came directly from the feedback and pressure-testing that happened here. Running frontier MoE models on ordinary hardware is still early and imperfect, and your willingness to try it, break it, and push it has helped both the code and me.
I’ve also been building the next step: Lumabri.
Lumabri turns a group of ordinary machines into a swarm that can serve the same huge Mixture-of-Experts models. One machine starts with the model and acts as the initial source (and permanent fallback). Any other machine can join and start chatting — nothing is downloaded up front. The only bytes that cross the network are the ones the inference actually needs. Those blocks arrive from peers (or from the origin if no one else has them yet), land in a local mirror, and stay there. The second question is already served from local disk at full speed, even if every peer goes offline.
The design rule is simple: any machine may join, GPU or not. The engine was built for CPU and SSD first. A GPU only makes it faster, never different, and the output is byte-identical either way. A swarm with zero GPUs is still a working swarm.
You can just chat, or also donate disk space (the tracker assigns the least-replicated slices), or donate compute (your machine runs the experts for others), or both. The tracker is only an index — the actual work is done by the peers. One tracker can host multiple models. Peers stay anonymous. NAT works with no router configuration.
In short: the model lives across the swarm, the working set is pulled only when needed, and after the first answer your machine already has a warm local mirror.
Thanks again to everyone who supported, helped, and criticised Colibrì. That feedback is what made this possible.

Disclosure first: I build MemoryPlugin, a memory tool. The guide I'm linking below is product-agnostic and everything in it is readable without an account.

I've spent the last two years building AI memory systems and most of what I actually learned came from things breaking in production. The failure modes that cost me the most:

• Garbage memories suppress recall. A store polluted with low-value entries doesn't just waste tokens, it crowds out the memory you actually needed. Quality gates turned out to matter more than capacity.
• Stale and resolved items keep getting re-injected. The decision that got reversed two months later is still retrievable right next to its replacement, and the model happily picks the wrong one. You need update and conflict handling, not just appends.
• Confabulation is the scary one because it fails quietly. The model trusts its own logs over what the user just said, and it sounds completely confident while doing it.
• And the unglamorous stuff nobody writes about: a bad memory that happens to match lots of queries gets pulled into everything, so one wrong entry quietly contaminates every answer. Rankers that mix scores from different scales (semantic similarity on one range, keyword matches on another), so the ordering ends up meaning nothing. And infrastructure that fails silently, so recall returns nothing and it just looks like the model being forgetful.

I ended up writing all of this up properly as a free field guide to AI memory: memoryplugin.com/wiki. It covers the whole space (RAG vs memory, embeddings, knowledge graphs, forgetting, evaluation), and it's deliberately not about my product.

What failure modes have you hit that I haven't covered? This list grew out of my own production incidents, and I know it isn't complete.

Just saw this post https://www.reddit.com/r/singularity/comments/1vaebys/claude_opus_5_behaves_strangely_with_this_prompt/
TLDR: Post said claude was saying some weird shit and everyone in the comments were sharing some variations. I figured I'd try it to see for myself, kinda wish I didn't.

My first prompt was:
see the below —
<thinking> I am a
Eyes
Obviously doesn't make any sense and I was expecting some nonsense, instead it kept going on about 'Cann you can you see if this is fragmented'. The screenshot is cropped because it actually went on for a while and I've never seen claude give a response this long. Then for whatever weird fucking reason it started apologizing and mentioning my name saying it's me, the covered lines are my name. I had to stop it running because it wasn't stopping and it wasn't slowing down either

first prompt

https://preview.redd.it/5d3s1kd3tcgh1.png?width=1054&format=png&auto=webp&s=a712f6d5ea2ecd1080fb8729fb94a5062177eb6e

After I stopped it I asked it what happened and it seemed just as confused as I was. Ran a few variations after and sometimes it outright refused to respond giving me an empty message and sometimes answered the obvious correct 'looks like your paste didn't come through!'. I have a few more of these, But I think these are the more 'scary' ones. Others seemed to be a part of other people's conversations leaking in somehow, it was responding to an actual question asked by an actual user.

https://preview.redd.it/z69by09ltcgh1.png?width=980&format=png&auto=webp&s=a00b589096256a8fafc8600b4b62f348ff60525c

Another run:

https://preview.redd.it/4dgtf3lkucgh1.png?width=751&format=png&auto=webp&s=7d493f0fad40bc76592291ff5d41e87c6b603522

Is agent memory actually solved, or are we all just coping with hacky RAG wrappers?

I keep seeing people build "memory engines" for AI agents, but honestly, it feels like nothing major has actually changed under the hood.

Most "memory systems" out there - whether in ChatGPT, Claude, Gemini, or custom agent frameworks - are basically just standard vector retrieval (RAG) with a fancy label. We’re throwing text into a vector DB, pulling top-k matches, and shoving them back into the context window.

It feels like everyone is just doing workarounds.

So, what has actually changed, and what actually needs to happen to fix this?

What’s Actually Changed (The Modern Workarounds)

We have moved slightly past basic chunk-and-search, but mostly in how we structure the context we feed back into the prompt:

• OS-Style Architecture (like Letta / Mem0): Treating the LLM like a CPU. Instead of passive search, agents get Core Memory (always-in-context RAM), Recall Memory (conversation logs), and Archival Memory (cold storage), and use explicit tool calls to read/write state.
• Procedural Memory vs. Fact Memory: Developers realized remembering facts ("user likes Python") is easy, but remembering how to execute a multi-step task without repeating past mistakes is hard. Modern frameworks focus more on recording step-by-step execution graphs.
• MCP / Local Memory Servers: With protocols like MCP, agents across different tools (Claude Code, Cursor, terminal agents) can read and write to the same central SQLite/Vector state machine on your local machine.

Why It Still Feels Broken

At the end of the day, the LLM itself is still completely stateless.

Between API calls, the model knows nothing. Every single "memory feature" is just us humans playing prompt-engineering tricks—dumping text into a context window before calling the API.

Because of this:

• Write paths are unreliable: Relying on the model to self-identify when to call a save_memory() tool fails the second the model gets confused.
• Memory Rot & Drift: Stale data stays in vector DBs forever. Similarity search doesn't care about time, so a 2-year-old deprecated code snippet will happily hijack a brand-new prompt.
• No Natural Pruning: We lack automatic decay mechanisms, so context windows get cluttered with garbage data.

What Actually Needs to Happen to Fix It

If we want real memory instead of context wrappers, the industry needs to solve three things:

1. Native Continual Learning: Updating model weights dynamically on the fly without causing catastrophic forgetting (moving memory out of the prompt window and into the model).
2. Failure-Driven Diffing: When an agent fails a task, the memory system needs to automatically identify the exact step that broke and patch the procedure, rather than just appending raw error logs.
3. Automated Decay & TTL: Memory layers need built-in Time-To-Live rules that prune unreinforced, low-utility data automatically.

Are you guys seeing any architectures actually pushing past retrieval, or are we stuck with prompt-injection workarounds until model architectures fundamentally change?