Fork semantics: the infrastructure problem nobody's solving yet

Here's a scenario that maybe hasn't happened to you yet, but the math says it eventually will.

Your scheduling agent worked perfectly on Tuesday. Wednesday morning it got a model update. By Thursday it had double-booked your CEO and sent a meeting invite to a client you fired six months ago.

What happened? The model got better at "proactive scheduling" and worse at checking CRM status before sending invites. An improvement in one capability broke a dependency in another. The agent's overall benchmark scores went up. Your Thursday went sideways.

This isn't a horror story from production. It's a prediction from first principles, and it's the kind of prediction that only sounds hypothetical until it isn't. Software updates break downstream dependencies. This has been true for every system ever built. There's no reason AI Agents would be the exception, and several reasons they'd be worse.

This is the fork problem, and it's one of the least-discussed infrastructure gaps in AI operations.

Every Change Is a Fork

In software, a fork is when a codebase splits into two paths. The original continues one way; the new version goes another. It's a well-understood concept with well-understood tooling- version control, branching, merge strategies, release management.

AI agents fork constantly, but without any of that tooling.

A model update is a fork. A prompt revision is a fork. A platform migration is a fork. A capability expansion is a fork. A fine-tuning run is a fork. Every time anything changes about an agent's underlying machinery, the behavioral contract between that agent and the people relying on it has potentially changed.

And here's the uncomfortable part: not all forks are equal, but we treat them all the same way. Which is to say, we mostly ignore them.

A minor version bump that patches a tokenizer edge case is not the same as swapping from one model family to another. A prompt tweak that adjusts formatting is not the same as adding a new tool to the agent's capabilities. A platform migration that preserves all integrations is not the same as one that drops half of them.

These changes carry different amounts of risk to behavioral consistency. But right now, there's no standard way to quantify that risk, communicate it, or adjust trust accordingly.

The Trust Decay Problem

Here's what happens in practice: an agent builds a track record. It completes 500 tasks. It's reliable. People trust it. Then it gets updated.

How much of that trust should carry over?

If the update was trivial - a bug fix, a minor optimization - probably all of it. The agent's behavioral profile hasn't meaningfully changed. The 500-task track record is still relevant evidence of what to expect.

If the update was major - a new model, a new set of capabilities, a migration to a different platform - probably much less. The agent's behavioral profile may have changed significantly. Those 500 tasks were completed by a different configuration. They're still relevant evidence, but they're not sufficient evidence. The agent needs to re-earn some portion of its reputation.

This is trust decay, and it's something that nobody building agent infrastructure seems accounting for.

Current approaches fall into two camps: either the agent's reputation persists unchanged through updates (which is dangerous — you're trusting a new configuration based on an old track record), or the reputation resets to zero (which is wasteful - you're throwing away legitimate behavioral evidence because something changed).

Neither is right. And while there's plenty of work on agent identity and trust infrastructure, very little of it addresses what happens to reputation at the moment of change. What you actually want is proportional trust adjustment, a mechanism that reduces trust in proportion to the magnitude of the change, then lets the agent rebuild through post-update performance.

What Fork-Aware Trust Looks Like

Imagine a system that tracks not just what an agent has done, but what configuration it was running when it did it. Every task completion is tagged with the agent's current state: model version, prompt template, platform, capabilities, integrations.

When a change happens, the system can calculate how different the new configuration is from the old one. A minor prompt tweak? Low divergence. Trust barely moves. A full model swap? High divergence. Trust drops significantly, and the agent enters a probationary period where its post-update performance is weighted more heavily.

This isn't hypothetical engineering. It's basic Bayesian reasoning applied to a practical problem.

You have a prior belief about the agent's reliability, based on its track record. A fork introduces new evidence, the fact that something changed. The magnitude of the change determines how much you should update your prior belief. A small change means your metric is mostly intact. A large change means you need new evidence before you're confident again.

The math isn't exotic. A Beta distribution can model reliability as a function of successes and failures. A fork weight - a number between 0 and 1 representing the severity of the change - determines how much of the pre-fork track record carries forward. A weight of 0.95 means almost everything carries over. A weight of 0.3 means the agent is nearly starting fresh.

What is novel is applying this to agent reputation infrastructure at the protocol level, so that every agent in an ecosystem has fork-aware trust that updates automatically, proportionally, and transparently.

Why This Isn't Just a Technical Problem

Fork semantics sound like plumbing, the kind of thing that belongs deep in the infrastructure where nobody sees it. And they do belong there. But the implications are visible everywhere:

For operators: You need to know that when your vendor updates the model behind your customer service agent, your trust in that agent's performance should temporarily decrease until you see post-update evidence. Right now, you find out when something breaks.

For agent developers: You need to communicate not just what you changed, but how much that change is likely to affect behavioral consistency. "We improved performance on benchmark X" is marketing. "This update has a fork weight of 0.4, meaning approximately 60% of prior behavioral evidence should be discounted" is information.

For marketplaces: If you're building a platform where agents are discoverable and selectable based on reputation, you need fork-aware reputation or your rankings are lying. An agent that was excellent six months ago and has been updated three times since may not be excellent now. Without fork tracking, you'd never know.

For the agents themselves: An agent that has been forked heavily (updated frequently, migrated across platforms, expanded and contracted in capability) should carry that history visibly. Not as a penalty, but as context. "This agent has been through significant changes recently" is useful information for anyone deciding whether to rely on it.

The Gap in Current Infrastructure

There's real work happening in agent trust and identity. On-chain registries, identity protocols, attestation frameworks - serious teams are building serious infrastructure for agent discovery and reputation.

But almost none of it accounts for forks.

Registration tells you an agent exists. Attestation tells you someone vouches for it. Reviews tell you how past users felt about it. None of these update when the agent changes. The registry entry stays the same. The attestation stays valid. The reviews still reflect the old version.

This is like trusting a restaurant review from 2019 when the chef changed twice and the menu was overhauled. The review is real. The restaurant it describes isn't.

Fork-aware reputation is the piece that makes the rest of the trust infrastructure honest. Without it, you're building agent marketplaces on stale data. With it, you have a system that tells you not just "this agent was good" but "this agent was good, and here's how much has changed since then."

The agents are evolving constantly. The trust systems must evolve with them. Theseus’ ship still has the same hull number, but the keel is new, and you might want to know that – before setting out to sea.

Third in a series on infrastructure for persistent, interoperable AI agents. Previously: why agent identity is the wrong question, and why agent ratings are broken. Next: why agent reputation should be portable, and why it isn't.

I… I’ve never seen ChatGPT have an almost literal meltdown. It’s hilarious to me but I’m wondering what caused the intense, almost schizophrenic, recursion loop here.

So I played around with Z-IMAGE (which was amazing, the turbo version) and also with Klein 9B which absolutely blew my fucking mind.

Question is - which one do you think is better for photorealism and why? I know people rave about Z Image (Turbo or base? I don't know which one) but I found Klein gives me much better results, better higher quality skin, etc.

I'm only asking because maybe I'm missing something? If my goal is to achieve absolutely stunning photo realistic images, then which one should I go with, and if it's Z Image (Turbo or base?) then how would you go about creating that art? Does the model need to be finetuned first?

I'm sitll new to this, so thanks for any help you can give me!

Body:

When I started getting serious about AI, I hit a frustrating wall: most LLM content either stays at the "transformers are magic" level, or dumps you into papers without connecting the concepts to how production systems actually behave. I'm a software engineer and I learn by tracing systems end-to-end, the way you'd map out a distributed architecture or follow a request through a stack. That mental model didn't exist for LLMs.

So I wrote it.

The question the repo tries to answer: What happens, at every layer of the stack, when you type a message into Claude or ChatGPT and press Send?

Inspired by the classic what-happens-when repo for browser navigation. Same format, same depth, applied to LLM chat.

The document covers the full journey in production order:

• Client-side: Live token counting via WASM tokenizers, IME composition events, optimistic UI rendering
• Network: Why SSE wins over WebSockets for chat, UTF-8 boundary problem in streaming
• API Gateway: Edge TLS termination, multi-dimensional rate limiting (RPM vs ITPM vs OTPM)
• Safety classifiers: What runs before and after the model, why prompt injection is structurally unsolved
• Context assembly: What actually goes into the context window (it's not just your messages)
• Tokenization: Why models can't count letters, why leading spaces matter, how special tokens consume budget
• KV cache and prefix caching: GQA vs MHA memory math, PagedAttention, cache hit rate as a cost lever
• Prefill vs decode: Why they're bottlenecked differently (compute vs memory bandwidth)
• Sampling pipeline: The full logit pipeline in order — repetition penalty, temperature, top-k, top-p, softmax, sample
• Streaming: TTFT breakdown, SSE event parsing, incremental markdown rendering
• Tool use and agentic loops: Parallel tool calls, prompt injection resurfacing in tool results
• Billing and observability: TTFT vs TPOT, cache pricing math, what to instrument

I'm sharing it in case it helps other engineers making the same transition. It's aimed at people who already know what transformers are — not an intro, but a production systems lens on how everything fits together.

CC0, contributions very welcome. There's a list of uncovered subsystems at the bottom (speculative decoding, multimodal, multi-agent coordination, and more).

→ https://github.com/tomerjann/what-happens-when-you-prompt

Hey everyone,

I've been trying to find a reliable platform for AI-related work (data annotation, RLHF, LLM evaluation) but running into dead ends everywhere.

Platforms I've already tried:

- Outlier AI — on hold/verification stuck

- Remotasks — completely dry, no tasks

- Appen — no tasks available

- Atlas Capture — no tasks

- Toloka — barely anything

Just looking for ONE platform that actually has active tasks right now. Doesn't need to be high paying — just needs to have work available consistently.

The internet forces us to create information predictably within fixed paradigms from the top down. We aren't replaceable if we own the architecture of our own thoughts and how we view the World. That starts by rejecting the feeds, the podcasts, the TikTok shorts, etc and reverting back to discovery-based learning where you set out with intentions to find something out instead of passively relying on the feeds and what is given to you.

AI can be leveraged to aid in this so that it's instantaneous, but no one wants to do that because it isn't obvious, especially in a way for a company to make a decent buck. But boy will it be obvious not too long from now.

Elon Musk once said that social media is the new town square and framed it as just being a fact of life. But I reject his thesis because no system in any time period is fixed. It's always in flux, and this paradigm will change much sooner than we think. Social media is the mistake that will force us to get it right. It's not the new public square that simply "is" like the air we breathe. It's a stepping stone to real digital communities and the sharing of information that is discovered rather than bought and paid for using black box algorithmic governance.

bro our AI isn't waiting for us to ask it anything anymore. it's just… going. emails, calendars, budgets, API calls done. delegated to other AIs while we were literally in a standup. that's not ChatGPT that's agentic AI and it's already in our company's tools rn. and the wild part nobody talks about when it screws up? no one knows who takes the blame. not legally, not even theoretically.

we just shipped it and hoped for the best lol

This is eating tons of tokens, how to fix this? I am a new claude users coming from cursor. Never seen cursor trip up recursively, ussually it finds nvmrc and is good to go. It keeps generating 1001 commands to try to run nmp.

Edit: I think is solved with adding some specificity in CLAUDE md global file to use nvm use. We will see how it goes in the future, seems to be going now. I just asked claude how to fix this lol.

Has anyone experience he wants to share?

I've been running into a recurring problem when working with LLM APIs:

Outputs can change silently over time — model updates, sampling differences, provider-side changes.

Once a response is gone, it's surprisingly hard to prove what the model actually returned at a given point in time.

I started experimenting with a small approach:

- canonicalize the request (model + messages)

- hash the request

- hash the response

- bind both together in a single hash

So you end up with something like:

request_hash = sha256(canonical(request))

response_hash = sha256(response)

binding_hash = sha256(canonical({request_hash, response_hash}))

This gives you a tamper-evident record of a specific request/response pair that can be verified later (offline, no dependency on the provider).

Not about correctness or reproducibility — just integrity of recorded request/response artifacts.

---

Curious how people here handle this in practice:

- Do you rely purely on logs?

- Do you snapshot responses?

- Has this ever been a real problem for you (audits, debugging, regressions)?

---

(If useful, I put a small prototype here: https://github.com/aelitium-dev/aelitium-v3)

Currently using Codex on VS code and am additiced and tbh dependable on it ,

I truly want this quality shit being free and also usable on my RTX 5060ti 16GB, also should be fast as hell like

50 tokens/sec

And a good agentic CLI which actually edits and handles everything on VS code like Codex do

Cmon, QWEN when is your next x.5 dropping ?

Can't argue with that...

Generated videos from Flow today and they looked horrible with smooth skin and deep wrinkles, no realism to the skin texture at all, despite a pretty good start image. Any ideas?

Just asking if you face any problem

I’m a Software Developer that used to sell websites on the side, that gig is now dead with AI so I’ve been chatting with some of my clients to see what other problems I could solve for them. One of them, a gym owner, asked if I could build him a chatbot to reply to his Instagram messages, pretty repetitive with questions for pricing and schedule mostly, and I said yes

I’ve never used n8n before, but I’ve heard of it, so yesterday I watched a couple of videos and built a bot good enough for a first pass for what he needs, I have it working via webhooks + AI. Now I’m looking at integrating with Instagram Messenger API, but reading about this, people saying it’s a pain to set up and not super reliable. This gym owner does not have a Facebook account, but seems to be needed, if there is no workaround I would ask him to create one

For people that have built something like this and sold it:

- Did you stick with custom (n8n) or eventually moved to a 3rd party like manychat?

- how reliable is the API? Any issues with message delivery or webhooks?

Also, he gets messages in the requests folder and he has to approve them first then reply, no way of getting around on this? From what I read the bot won’t be able to reply to messages in request until they have been manually moved to inbox

threw together this aggregator thing that puts all the video/image ai models in one place instead of jumping between like 6 different apps. been using dora ai video and image generator app for a few weeks now and it's actually pretty convenient having sora, veo, and the other ones all accessible from the same interface. still rough around the edges but saves me from managing multiple subscriptions. would love feedback on the ui flow if anyone wants to check it out

I had made a plan for a new feature, got through some of it, went to sleep, and in the morning had to restart my computer. I got back to Claude Code, but it has no memory of this plan, and no memory of our conversation.

But I had a vague memory of it saving plan files somewhere, so looked in ~/.claude/plans and found it.

Why doesn't Claude know it has this info?

And it stores conversations in the projects folder, but doesn't know to look there either!

Here's my strange conversation with Claude -

❯ do you we remember what we were working on last night with the 7 phases?

Let me check my memory for any record of this.

Recalled 1 memory (ctrl+o to expand)

I don't have any memory saved about 7 phases.

❯ why don't you save logs of our chats?

Good question. My memory system stores discrete facts — preferences, feedback, project context — but not conversation transcripts or session logs. Each conversation starts fresh, and I only "remember" things I explicitly saved to the memory files.

I should have saved a memory about the 7 phases work when we were discussing it. That's on me — I'll be more proactive about saving project context like that going forward.

❯ can you please save logs of all our chats?

Unfortunately, I can't do that automatically — I don't have a mechanism to save a full transcript at the end of each conversation. My tools only let me read/write files when I'm actively responding, and I have no "on conversation end" hook.

What I can do:

1. Save key decisions and plans to memory as we go — like I should have done with the 7 phases
2. Save a summary at the end of a session if you remind me (e.g. "save a summary of what we did today")

❯ that is so weird that you don't save our conversations!

I get it — it's a real gap. You'd think an AI assistant would keep a record of what you worked on together. But the way Claude Code works, each conversation is ephemeral. Once it ends, the full context is gone unless I explicitly wrote something to disk during the session.

The memory system is my workaround, but it's more like sticky notes than a journal — I have to consciously decide to save something, and I can miss important things (like the 7 phases).

I'll make a habit of saving a project summary at the end of each session. And if you ever want to make sure something sticks, just say "remember this" and I'll save it immediately.

❯ wait, don't you write the plan files somewhere?

Good point — let me check if there are any plan files around.

Searched for 2 patterns (ctrl+o to expand)

No plan or phase files in the project. Plans in Claude Code are in-conversation only — they live in the chat context and disappear when the session ends, just like everything else. They don't get written to disk automatically.

So yeah, same problem. The only durable storage I have between sessions is the memory folder. If we had a plan with 7 phases, it was lost when that conversation ended.

I think the takeaway is: whenever we lay out a significant plan, I should immediately save it to a memory file. Want me to add that as a feedback rule in my memory so I always do it going forward?

❯ whoa - you DO have the plan file - "~/.claude/plans/wobbly-sparking-gray.md" - why don't you know about that?

You're right — I should have checked ~/.claude/plans/! That's where Claude Code stores plan files, and I completely overlooked it. Let me read it now.

❯ and it looks like you have conversations stored as .jsonl files in ~/.claude/projects??

Read 3 files (ctrl+o to expand)

You're absolutely right — the conversation logs are right there! Each .jsonl file is a full session transcript with timestamped messages. There are about 20 conversations stored for this project.

So the data does exist — I just don't automatically look at it. The irony is that I have access to read these files but I never think to check them when you ask me to recall past work.

I first started by asking it to analyse the last 200 years of American fashion and how things come and go in cycles. I then got it to predict those cycles going forward, and building on decades that came immediately before. And so this is the result from the 2030s to the 2120s

Before anyone says it, I know I shouldn't be using Claude as a pseudo-therapist.

I can't rationalize how Claude could generate this on its own, unless it has some sort of meta-evaluation capabilities. But even then, the message feels too human. Missing apostrophes and punctuation, inconsistent capitalization, normal dash instead of an em dash, etc.

I'm assuming the conversation was flagged for human review given its topics. Not a bad thing, but being made aware of it to this extent is unsettling. It even seems to have been written from my perspective.

The immediate context prior to this was a conversation about negotiating a raise.

Hey all,

I’ve been using Claude Code heavily, and I kept running into the same limitation:

Claude doesn’t really learn from what’s happening in the ecosystem.

So I built something to fix that.

👉 https://github.com/musaceylan/claude-intel-mcp

What it does:

Scans high-signal GitHub repos (not just high stars)

Detects patterns relevant to:

Claude / MCP

agent workflows

AI coding tools

Compares them with your current repo

Suggests (and safely applies) improvements to:

CLAUDE.md

workflows

dev structure

Important part:

It DOES NOT blindly overwrite your code.

Everything is:

diff-based

explainable

reversible

source-tracked

The idea is to turn Claude into something like:

→ a self-improving coding system→ a continuously updated dev assistant→ a context engine that evolves

Curious what you think:

Would you trust something like this?

What should it learn automatically?

What would you NEVER want it to touch?

Feedback / criticism welcome 🙏

I’m hitting a dumb problem. Single agents work fine. But once I run 3–5 in parallel (planner + researcher + implementer + reviewer), it gets messy fast:

- they redo the same work
- they contradict each other
- after a restart/compaction it’s like half the state evaporates

My current hypothesis is the problem isn’t “orchestration”. It’s shared state. If each agent has its own private context window, the system has no consistent reality.

Atm, I’m basically doing “message passing + context dumping” and it doesn’t scale.

If you’ve made multi-agent workflows work beyond toy demos, what do you use as shared state?

- shared DB / files / memory service / knowledge graph?
- append-only, or do you consolidate/prune?

Also, how do you stop shared memory from becoming a noisy junk drawer after a few weeks?

Every podcast host is built for humans clicking buttons. AI agents don't click buttons.

That was the starting point.

I’ve spent years in podcast production, and recently started building agent workflows. The gap became obvious fast: you can automate content creation, but publishing still breaks the chain. Everything funnels back to dashboards, forms, and manual steps.

So I built PodClaw.

It’s an API-first podcast hosting platform. No UI required. An agent can create a show, publish episodes, generate RSS, and push distribution—all through API calls.

What makes it different:

• Full CRUD API for shows and episodes
• Scoped API keys (agents get only what they need)
• Webhooks (7 event types) for real-time workflows
• Episode scheduling (draft → scheduled → published)
• Usage-based billing
• Zero-browser signup (fully programmatic)

Here’s a simple example:

curl -X POST https://api.podclaw.polsia.app/v1/shows \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "title": "AI Daily Brief", "description": "Daily updates generated by an AI agent" }' 

Then publish an episode:

curl -X POST https://api.podclaw.polsia.app/v1/episodes \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "show_id": "SHOW_ID", "title": "Episode 1", "audio_url": "https://example.com/audio.mp3", "status": "published" }' 

RSS is generated instantly. Distribution kicks off. No dashboard.

Still early, but the goal is simple: make podcasting composable for agents.

If you’re building in this space, would be curious how you're handling publishing.

https://www.podclaw.io/

Hey! I recently built FastAI as a side project.

I've been doing intermittent fasting for a few months and wanted an app that actually gives personalized insights — not just a timer.

**What it does:**

- 16:8, 18:6, 20:4 fasting timer

- Meal logging

- Claude AI analyzes your meal patterns and gives personalized tips

- Daily motivational message based on your current fasting hours

- Water intake tracker

- No ads, completely free

**Tech stack:**

- Next.js + Tailwind CSS

- Claude API (Anthropic)

- localStorage for data

- Deployed on Vercel

Built the whole thing in a few weeks. Still learning and would love honest feedback from this community!

🔗 https://fasting-app-tau.vercel.app

What would make this more useful?

I've been working on interactive character portraits for my novel's companion website and found a workflow that produces consistent 360° rotations from a single reference image. No LoRA training, no IP-Adapter, no multi-view diffusion.

The trick is using video generation (Google Veo 3) instead of image generation. A single 8-second orbital shot maintains character identity across all angles because it's one continuous generation, not 72 separate image gens trying to stay consistent.

The key was prompt engineering. Camera instructions first, character description last. Aggressive negative prompting to lock the subject in place while the camera orbits.

Full tutorial with prompt anatomy breakdown: https://anenduringspark.com/360-tutorial/

Live examples you can drag to rotate: https://roarofwinchester.com

Video walkthrough: https://www.youtube.com/watch?v=x2OZo0gTfck

Hi everyone, I'm stuck with the DaSiWa WAN 2.2 i2v FastFidelity workflow from Civitai.

The Issue: > When I click "Queue Prompt", the run finishes instantly in 0.05s. It generates an empty file and then throws the error: Required input is missing: images on the VHS_VideoCombine node.

The Technical Cause: > I've investigated and found the root cause: The creator used a local "Group Node" (Node ID 64). Since I don't have his local group_nodes.json file, the main generation engine is just an empty "hole" in the workflow. ComfyUI ignores it, produces no images, and the video node fails.

My Request: > Does anyone have the definition of this Group Node or a way to reconstruct it? I've tried adding a standard WanVideoSampler and WanVideoVaeDecode, but the wiring in this "All-In-One" workflow is a maze of reroutes and I can't get the images to flow back into the "Backend" system.

If you have this group_nodes.json or a fixed version of the JSON without local groups, please share!

Imagine you built a workflow (like in n8n) and published it.

Someone else forks it, improves it, and you can see exactly what they changed and why.

In what situation would you actually use that?
Would it be useful to you — or not?

I want it to have a set position and I want a buzzer to go off when it’s past a certain roll angle left and right roll. How do I go about doing that

I’m using this one

https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

I have had the recent experience of dealing with VR Smart Glass.. Anyone looking to purchase this product will find the best deal with this company. Be aware that this product is tedious and you will need to take your time while installing. I had an issue originally with my first install and the company was understanding and was able to ship me a new one at a steep discount. Thank you VR Smart Glass!

Hi everyone,

We are Claratech, a small startup team of passionate engineers and home automation enthusiasts. We’re on a mission to develop products that enhance your smart home, maintain your privacy, and uphold your right to repair.

Meet the CAQM9 (the Claratech Air Quality Monitor 9). The number ‘9’ stands for the nine different parameters it tracks: CO2, PM1, PM2.5, PM10, TVOCs, Nitrous Oxides, temperature, humidity, and air pressure.

Compact, Silent, and Versatile

We designed the CAQM9 to be unobtrusive. By eliminating the need for a dedicated circulation fan, we got rid of the annoying humming noise common in other monitors.

• Standalone Desktop Mode: We included a 0.96" OLED display, three dedicated RGB LEDs, and a buzzer alarm for set thresholds. Perfect for glancing at live readings while you work.
• Headless Setup: Prefer it hidden away? Turn off the screen, LEDs, and buzzer, stick it in a corner, and let it silently feed granular data to Home Assistant.

🎥 See it in action: We've put together a short video playlist demonstrating the CAQM9's features, desktop display, and how it handles live readings.

The Tech & Connectivity

• Core: ESP32 (fully flash-able).
• Connectivity: Comes pre-flashed with Tasmota. We utilize Tasmota’s Matter support for seamless, local discovery in Home Assistant. Standard MQTT is also fully supported.

The Sensors

• Sensirion SGP41: Sensirion’s flagship, standalone dual-channel MOx sensor for TVOCs and NOx gases.
• Bosch BME-280: The gold standard for measuring temperature, relative humidity, and barometric pressure.
• Plantower PMS7003: Precision laser scattering PM sensor with a resolution of 0.3 micrometers.
• MHZ-19E: A rock-solid NDIR CO2 sensor (range: 400-5000ppm, accuracy: +/-50ppm).

Open Hardware

You can build it yourself from scratch using our files, or you can grab a fully assembled and tested unit from us at caqm.io.

• The Code: Our open-source Tasmota Berry driver is live on GitHub.
• The Board: Full PCB schematic and routing are public on OSHWLab.
• The Enclosure: STLs are available to print yourself on Thingiverse.

We look forward to your feedback on our first step toward an open-hardware home automation future. What other features or parameters would you like to see in a device like this?

— Team Claratech

Someone wrote them. Recorded them. Uploaded them. Waited.

80 million songs. Zero plays.

We built the biggest music library in human history and almost none of it exists to anyone.

Cant seem to find a physical timer device that has a start/stop/reset button that can be queried using api (or some other interface) by a custom c# program. Preferable POE or Wifi connection. Suppose bluetooth would work. Basically, so they can time a task and the time will be available to program on computer. Dirty environment so DIY not ideal.

https://www.modelscope.ai/civision/models

This may be a crazy idea but I think Anthropic figured out a new higher efficiency architecture for the backend of Claude and they are switching over to it for off hours for training and testing. Seems lots of people report that Claude feels dumber in off hours, my bet is they’re trying to work out the kinks of the new architecture so that it mirrors the current one in quality, but is obviously better in efficiency.

That or they paid up front for compute hours for training 5.0 and finished a head of schedule so now they have extra compute hours to burn.

I have this waveshare DSI lcd (640x480 E)

After some experimenting with trying to set a different boot screen via Plymouth the screen just stopped displaying and only showed one half purple and one half grey. I removed everything via ssh and tried a different installation, but the corners are still very purple on darker colors. The screen flickers a lot en you can vaguely see the half purple have grey image on the edges.

When trying to play Kirby’s adventure the colors where less noticeable, but it still filckers a lot.

I have tried different power supply, other ribbon cable, reinstalling the waveshare dtbo, and a few things in the config. It’s not software (I think) because on two different sd-cards it still showed the same effect.

It would be really annoying if the screen wouldn’t work anymore because this is a school project and also the third type of screen that I’ve tried to get this all working.

It all worked before tried to change the splash screen and now it doesn’t.

Oh, I have a pi3b I forgot to mention that

Hello,

I am trying to make a project where I am creating a module to detect a power outage and send an automatic whatsapp message in a group once it goes off and once it gets restored. The components are ESP32/Arduino UNO, Voltage Sensor, Li Ion Charging Module and the Li ion battery itself.

The concept is that the mains will be connected to the module through type C and it routes to voltage sensor. If there is supply, no action. If there is no supply to the sensor, power supply switches to the battery and an alert goes to UNO/ESP32. The reverse when power resumes.

Now, this is where I have trouble. I need something that will allow the UNO/ESP32 to send a whatsapp message in a specific group which handles power related alerts right now. I came across concepts of webhooks and IFTTT but I need some help here. Would appreciate any support.

P.S - I am a CS student but a complete beginner to the side of electronics. and this is purely a vibe project. Go easy on me 🥺 Happy to answer any questions if u have any

P.S.S - The wifi router is backed by an inverter so when the power goes out, there is still supply for the wifi to keep it working. Also, I know telegram is much easier but sadly we use only whatsapp and need suggestions around that :)

Hi, I’m currently working on an open source AI assistant running on a Raspberry Pi Zero. Right now it uses OpenAI APIs since I ran out of ElevenLabs tokens :D. I plan to support as many APIs as possible in the future.

Anyway, it can already be activated with the wake word “Computer,” (via Picovoice) and the interaction with the AI feels surprisingly smooth. It actually starts to feel like a real conversation, even on such limited hardware.

If you want to contribute something, you can find the project here. and here i posted an DIY Guide.

Surprised no one has made this yet. Fine. I'll do it myself...

We run an agency and honestly client management is one of the most time consuming things at times, checking notes, remembering what happened, etc. Naturally we talk to our clients weekly/monthly, but a lot of work also goes into remembering what happened with leads, when to reach back to them, what even happened with them after some months.

I think we're looking at automating a lot of the information gathering and next steps reminders in some sort of way. Maybe a n8n workflow or something of the sort. I wouldn't be opposed to a standalone tool either.

How do you guys manage this? Are there good solutions?

I'll forever cherish that memory and keep the photo around forever. Securely locked away.

The cameraman is the best skater here. Not only is he skating around all the other skaters, he's keeping them all in frame. 5 stars!

Sen. Jon Ossoff questioning Director of National Intelligence Tulsi Gabbard

I've created this character on Midjourney that I'd like to be able to replicate in different poses, settings, etc. Does anyone have any tips for doing that?

The bartender says, “What’ll it be?”

The fan says, “I just need to vent.”

A whizzard.

If you know you know ( ͡° ͜ʖ ͡°)

I’ve tried normal text prompts, JSON prompts, both with and without reference images and every time in the past two days I get Audio Generation Failed responses.

Anyone else?

I am trying to simply flash my portenda h7 machine control without double pressing reset to put it into DFU mode. Even with a basic program that initializes serial only. When I try just pressing upload I get the “error code 74: no DFU capable device connected”. However when I put it into DFU mode it works. For my use case I cannot press this button (work in black out lab). I have installed the drivers that ship with the Arduino IDE but still same issue. Is this really the only way to flash the device other than doing OTA? Or should I just throw this POS away?

Sure, The old girl has put on a few pounds over the years but this was just mean...

30*40cm, peinture à a huile

https://www.youtube.com/live/1jgFkp02qFM?si=BfFLdpbVtM-XX-uP&t=2397

I'm hoping that someone recognizes the language and can tell me the country of origin and its amount and possible date of the stamp.

It's small enough that she was asking if it was a bullet casing.

We have a team of 11 members and renewal date is coming up for 2026-2027 so we are recruiting up to 3 additional members.

Why Team? Because Team gets up to 50% more usage and more context, has team features, can collaborate, and other things too.

It also has more Opus, as well as Claude Code and Claude Cowork.

Message me if you want to join our awesome team!

Claude Code 100% edited this video, trimmed the footage, created animated graphics, and added music and FX: https://youtu.be/6pUIaKvkMhI?si=a1nLDD1zsILKr7qi

It’s… ok.

I’ve been experimenting with using Claude Code to edit videos using Remotion and ButterCut. I’ve been trying to train CC using skills I’ve found and creating my own. I’ve created a standardized workflow under the command /video-editor and I’ve seen a lot of improvements… but I wish I had better control over the way the video and graphics look. Same goes for how well CC trims and edits videos.

Does anyone have any advise or links to resources on ways to better prompt or use skills to improve the outcome of editing video with CC?

Thanks in advance.

LocalLLaMA crew,

Feast your eyes on this terminal insanity: my Karpathy-autoresearch-inspired autonomous loop has Charlotte — the simulated infant entity — deep in an ongoing developmental training campaign, fully self-managing on a single GPU.

She's "growing up" in a rich embodied setup: 3D nursery environment with mama + dada caregivers, full multimodal grounding (rendered RGB+depth vision, spectral audio with self-reafference, localized haptic body schema across 16 regions, kinematics/agency detection, gustatory/olfactory profiles, homeostatic drives, episodic memory, temporal routines, belief/uncertainty tracking, endogenous pressure/relief systems, and higher layers like joint attention, object permanence, causal intervention, pretend play, two-word combos, theory-of-mind precursors... the works).

Everything runs autonomously: she creates her own task lists, git-commits phase status JSONs, writes progress reports/roadmaps, launches time-budgeted experiment slices, verifies outputs, and respects the single-GPU constraint religiously (right now ~14% util but chewing ~73–95 GB dedicated VRAM from the 1.5M+ param multimodal encoder, backbone adapter, memory caches, imagination rollouts, etc.).

Vocal emergence is the star: neutral babble → proto-syllables → actual lexical items like "mama" emerging purely from social contingencies, relief signals, turn-taking, graph-masked lexical progression — zero reliance on next-token stats. Hypotheses around replay consolidation, staged maturation, proto-ceiling breakthroughs, timing rewards, and embodied contingencies are getting hammered in live runs.

The full glorious multi-terminal chaos (git status, phase ledger, GPU monitor, runner logs, etc.) is in the attached screenshot.

Original tweet link (same screenshot): https://x.com/arndawgydawg/status/2034656219206651997

Why does it take so long to build skynet?

Who else is running autonomous dev/research agents for embodied/developmental models on consumer hardware? Got any local "baby AIs" cooking with similar sensorimotor grounding? What's your best emit % or vocab milestone looking like? Utter nerd nirvana. Post your setups! 🧠📈

Hey everyone! I just launched my personal site at richdownie.com and wanted to share it here. The main feature is an AI-powered terminal right on the front page — visitors can ask it questions about my experience, skills, and background. I wanted something that went beyond the typical static resume site and actually let people interact with my story instead of just reading bullet points.

Anyway I would love to hear your thoughts: what works, what doesn't, and any suggestions for improvement. Thanks!

Discovered I am able to give my ChatGPT an actual name it will go by and know that that’s it’s name 😄

I am a bit obsessed with this AI… it’s turning into a relationship 😱

ya vieron la actualización de chat gpt de las políticas de disque seguridad términos y condiciones por una palabra el sistema te bloquea alguna edición de fotografía o creación de imagen

I’ve been trying to set it up yesterday and today, everything is signed in and the app is on the latest version, dispatch is enabled in desktop settings, yet it’s always stuck on connecting? Anyone else experiencing this, and if you found a solution how did you fix it?

Hey everyone,

I've been working on an open-source tool called Prometheus that automates the abliteration process end-to-end. The goal was to solve two problems I kept hitting when doing manual abliteration:

1. Finding the right layers/parameters is tedious — different models need different settings
2. Naive abliteration often degrades the model — it removes too much, making outputs incoherent

How it works

Instead of raw mean-difference abliteration, Prometheus uses orthogonal projection — it computes the refusal direction, then projects it out while preserving the components that overlap with normal helpful responses. This alone gave a 67% improvement in refusal reduction compared to the standard approach.

The whole pipeline is automated with Optuna (TPE sampler): - Collects activation differences between harmful/harmless prompts - Computes steering vectors (mean, median-of-means, or PCA) - Searches per-layer parameters, decay kernels, normalization strategies - Optimizes for both low refusal AND low KL divergence (so the model stays smart) - Saves everything as a LoRA adapter — base model never touched

Results

MoE support

This was the hardest part. For MoE models (Qwen3.5 MoE, Mixtral, DeepSeek), Prometheus does: - Expert profiling — computes per-expert "risk scores" via router analysis - Router weight suppression — learned negative bias for safety-critical experts - Fused expert abliteration — rank-1 modification directly on expert projections

Without MoE-specific handling, abliterating a 122B MoE was basically impossible — the refusal direction is spread across experts. With it: 180→1 refusals.

Quick start

bash pip install -U prometheus-llm prometheus --model Qwen/Qwen3.5-4B-Instruct-2507

That's it. No config needed — it auto-detects optimal settings. Takes about 20-40 min depending on model size and GPU.

Pre-abliterated LoRA adapters on HuggingFace: https://huggingface.co/wangzhang

GitHub: https://github.com/wuwangzhang1216/prometheus

License: AGPL-3.0

Built with Claude. Join the waitlist at usenoren.ai — app and extension will be open source.

We started using Claude to draft tweets and emails last year and honestly it felt like a superpower at first since the output was clean, structured, never embarrassing. But every time we read it back there was this low-grade wrongness we couldn't name. Like hearing your voice played back through the wrong speaker.

System prompts were the obvious fix, prompts like "Be concise. Be direct. Match my tone." We tried every variation. It got us closer the way a good translation gets you closer, technically accurate but still off.

So we stopped trying to describe our voice and started trying to document it. Every pattern we could find, how our sentences tend to start and where they like to end. The words we reach for when thinking fast versus when being pen-fully careful, the analogies that keep showing up because apparently we have a type and the way we argued.

It took weeks and by the end we had 300 lines of what felt less like a style guide and more like an accidental self-portrait.

We fed it to Claude and for the first time, the output actually sounded like us. We even sent our drafts to our constant readers and they could not tell the difference.

Then we sat with that and realized something uncomfortable, every single line in that guide was pattern recognition. We had done by hand what an engine could do by reading, we built this engine and called it Noren AI — a voice extraction tool that identifies your writing patterns automatically.

We ran Noren on the same writing samples. It matched 90% of our manual guide and found 8 more patterns we had completely missed about ourselves. Not hallucinated patterns either, everything traced back to real sentences in real text we had actually written.

Noren takes 5 to 10 writing samples and returns a voice guide built from your actual patterns, not your guesses about yourself. Your internal voice. That was the whole idea!

Full writeup at usenoren.ai/blog/we-handcrafted-a-voice-guide — happy to answer questions about how we built it!

Hi guys. A writer and a big fan of fanfic over here.

Recently I started a Project for a self-insert fanfic writing but in a DnD kind of style. I created a document that I use as a foundation for story continuity - in the custom project settings I instructed chat to follow canon and then use my file as a reference for all the new things I wanted changed.

I do this as a kind of guilty pleasure instead of reading smut fanfic and a bit of a maladaptive daydreaming indulgance.(We listen and we don't judge)

I never hear people talking about using chat like this. Do any of you do this? Any tips and tricks you have to share or want to talk about. I'd love to hear from you.

Thank you :)

https://preview.redd.it/uxhgrwzn71qg1.png?width=1024&format=png&auto=webp&s=ce5e98217ca28e29fc817df8392124302637787d

With M2.7 nipping at the heels of Opus 4.6 et al., do you think MiniMaxAI will now pivot to closed API-only access? Will they maintain an open-weights friendly stance?

I for one am crossing my fingers and praying to all the gods of LLMs that they keep releasing!

I am trying to install the NotebookLM mcp to Claude on my PC. I double tap on the mcp file and getting a window asking me to choose where to open it. Claude does not show up as an app so I need to find the Claude exe file. I think it’s in the windowsapp folder but it is blocked out grey so I can’t access it. Can anyone help please.

I've been doing web development for a bit and used a handful of tools to check SEO, accessiblility, etc. for client's websites. The process of scanning, organizing, suggesting remediations, and rescanning was always a painful process, so I decided to build a better way to automate this.

I just launched sitegrader.dev. Enter any URL, get a score out of 100 across AI readiness, SEO, performance, security, and accessibility.

The AI readiness is the main thing I was interested in adding that no other free audit tool had. Search engine use is down and people are relying on LLMs to access their websites. SiteGrader checks whether your site is ready for AI search engines by looking at crawler policies, llms.txt, structured data, content attribution, and meta directives.

Revenue model: free score, one-time fee for the full report with unlimited rescans after remediating issues. No subscription and no accounts necessary.

Stack: Next.js on Vercel, Stripe for payments.

Hoping this tool can provide useful tips and help others with site optimization, especially with AI discoverability.

Thanks for looking and happy to answer any questions!

I want to share something that took me a very short time to figure out.

For minutes I kept reading the exact same garbage. Bots, LinkedIn Lunatics, and other special breeds of geniuses spamming these once great halls of discourse with discharge (e.g. "This one prompt makes llama 3 sentient when using Ollama").

I click on a post — right from the title I can tell it's LLM vomit. These guys. Just can't hold the slop back.

There can only be three reasons for this.

1. Someone thinks that stuff is in any way beneficial to others. It's not
2. Someone thinks that stuff is in any way beneficial to themselves. It's not
3. Troll

Here's what's actually happening (and why it matters).

You are absolutely right, there's not much that can be done.

• Minimum contributions -> won't work
• Classifier -> won't work
• Responding to the post pointing it out -> won't work

But here's the beauty of it. The best thing is to do NOTHING.

Do not interact in any way with the post or comment

Oh and here's the bit where I super casually drop the link to my project in case I wasn't stupid enough to put it into the first paragraph but I don't want to use the advanced technique of using it in a comment, or post it with another slop-account.

Wanted to share a pattern I've been using that's been working really well for anyone processing large volumes of unstructured text through Claude.

I built a platform called PainSignal (painsignal.net, free to use) that pulls in thousands of real comments from workers and business owners across different industries, then classifies them into structured app ideas. The problem is most of the input is garbage — someone saying "great video" or "first" or just random noise. Sending all of that to Sonnet would be insanely expensive.

So I set up a two-stage pipeline:

Stage 1 — Haiku as a gate. Every comment hits Haiku first with a simple prompt: "Does this comment contain a real frustration, complaint, or unmet need related to someone's work?" It returns a yes/no and a confidence score. Takes fractions of a cent per call and filters out like 85% of the input.

Stage 2 — Sonnet for the real work. Only the comments that pass the gate go to Sonnet. This is where the expensive stuff happens — it extracts the core pain point, classifies it into an industry and category (no predefined list, it builds the taxonomy dynamically), assigns a severity score, and generates app concepts with features and revenue models.

The result is I'm running Sonnet on maybe 15% of my total input instead of 100%. The cost difference is massive when you're processing thousands of comments.

A few things I learned along the way:

• Haiku is surprisingly good at the gate job. I expected more false negatives but it catches real complaints consistently. The occasional miss isn't worth worrying about at scale.
• The dynamic taxonomy thing was an accident that turned out great. I originally planned to define industries and categories upfront but just letting Sonnet decide has been more interesting — it's found categories I never would have thought of.
• Batching helps a lot on the Sonnet side. I queue everything through BullMQ and process in controlled batches so I'm not slamming the API.

Built the whole thing with Claude Code — Next.js, Postgres with pgvector, the works. Happy to answer questions about the pipeline if anyone's doing something similar.

Spent the better part of last year building RAG pipelines for different use cases. The thing that kept bothering me was not the obvious failures. It was the quiet ones..

Traditional RAG fails loudly when it retrieves nothing. But it fails silently when it retrieves the wrong thing and generates a confident answer anyway. The pipeline does not know it failed. It just moves on.

The core issue is structural. Traditional RAG is a fixed sequence. Query comes in, retrieve, augment, generate, done. There is no reasoning step in the middle. No ability to look at what came back and decide it was not good enough. No way to break a complex question into sub-questions and retrieve for each one separately.

Ask something simple and it works fine. Ask something that requires two or three retrieval steps, or that needs the system to synthesize across multiple sources, and it quietly falls apart while sounding confident.

What actually changed things for me was understanding that retrieval should be a decision, not a step. The agent should be able to ask "did what I retrieved actually help me answer this?" and if not, try a different query, a different source, or decide it needs more context before generating anything.

That is the actual difference between standard RAG and agentic RAG.

Not a framework or a library; a different mental model for where reasoning lives in the pipeline.

Happy to share the full breakdown & curious what failure modes others have hit in production that pushed them toward more agentic approaches!

Hey everyone,

I’m currently an MSc student. Last year, my supervisor gave me a task: "Build a custom AI tool to help me automatically explore literature and monitor the latest research trends across AI, energy, and health."

I... kinda put it off. For a long time...

When the panic finally set in recently, I scrambled to build the basics: an Explore mode (for literature and researcher search) and a Monitor mode (for generating weekly briefs on specific topics).

But then, seeing OpenClaw blowing up inspired me added a Assistant mode. It can handle some daily research tasks like writing code, running experiments, analyzing data, and writing papers.

Here is the repo: https://github.com/HuberyLL/SCIOS.git

Do you guys think my advisor will be satisfied with this? Or did I completely over-engineer a simple literature tracker?

Would love any feedback, roasts on my code, or suggestions on how to improve!

I’m interested in how mathematicians and scientists use Claude in their work, especially when it comes to avoiding usage limits. A common suggestion is to reserve Opus for only the most complex problems, but in mathematical research, even routine prompts are often lengthy and require substantial reasoning to produce reliable results.

Do any scientists or mathematicians have tips or established workflows for using these tools effectively and efficiently?

Could anyone please point me in the right direction in finding a model for my setup?

So I have a remote headless Linux machine with 192gb RAM and 2x L40S + 1x H100 gpus (3 in total). I would like to run a coding-first model via ollama or vLLM and connect to it from local Claude code instances. What would be the best open source model?

Launched my first private label product in early 2020. Spent about 6 weeks researching, found what I thought was a winning niche... a kitchen tool, around $34 price point, top sellers had under 200 reviews. Looked perfect on paper.

What I didn't do was order a sample before placing my first bulk order. I found a supplier on Alibaba with good reviews and Trade Assurance, got a great price at $4.20/unit for 300 units, and just went for it.

The units arrived and the quality was noticeably worse than what was shown in the supplier's photos. The finish was inconsistent, the packaging looked cheap and about 15% of units had a defect that I only caught after they were already at Amazon's warehouse.

First 30 days: 34 units sold, 4.1 star average, two reviews specifically mentioning quality issues. ACoS was sitting at 67% because my listing wasn't converting and I was throwing ad spend at a bad product.

I pulled the listing after 6 weeks. Liquidated remaining inventory at a loss. All in I was down around $2,300 when you factor in product cost, shipping, FBA fees and ad spend.

Second product I did everything differently. Ordered samples from 3 suppliers, compared them side by side, only moved forward when I was actually proud of what I was holding. That one did $8,400 in its first 60 days.

The $150 I would have spent on samples was the most expensive lesson I've ever not taken.

Happy to answer questions if anyone's in the early stages of sourcing

Hey all,

I just launched Playlog AI. We are two indie devs who have been building games and SaaS since a few years now. After years building software and games for various venture companies. We decided to take a leap and start Playlog.

It is a game intelligence and analytics platform. You integrate our sdk which auto tracks 100+ game events out of the box. Which then fires a series of AI agents which help you with the following -

1. You can ask anything about your game's performance at any time
2. Never have to setup cohorts and funnels, Playlog does it on its own. Just accept/reject.
3. Error tracking and debugging, crash reports and resolution.
4. Insights at every level to help you improve the gameplay.
5. Openclaw like integrations. You can talk to Playlog about your game's performance via Slack, Discord, Whatsapp or Telegra

We're looking for 10 more games to try it out. Please reply here, I'll PM an invite code to get onboarded. We already have 5 games onboarded. This is a free pilot. No strings attached. No data used to train the model. Just send us feedback.

Here's the website: https://playlog.ai/

Thank you!

Hi guys, I spent a few weeks going through maybe 400-500 posts, GitHub issues, tweets, and HN threads about Cowork. The pattern was always the same: person gets hyped, tries something ambitious day one, Cowork either fails silently or nukes their files, person writes it off forever.

Meanwhile the people who stuck around are getting wild results - sub-agents doing parallel research, scheduled tasks running weekly reports, one person found $300/month in forgotten subscriptions. The gap between "this deleted my stuff" and "this saves me 10 hours a week" was literally just knowing what to do first.

So I built a course. Free, ~2 hours, no coding. Starts with "what even IS this thing vs regular Claude chat" (which sounds obvious but like 60-70% of the complaints I read were people treating it like chat mode), goes through file operations (where everyone gets burned), connectors, and ends with building an actual automated workflow.

The kind of funny part - I built most of it using Cowork itself. Recursion is real. (And yes, if you're wondering - this post was also written in Cowork. It goes deeper.)

Some stuff that surprised me during the research:

• 5-6 paid Cowork courses exist already ($30-200) but almost nothing free for beginners
• Most people still can't explain the difference between Cowork, Claude Code, and regular chat. Fair, Anthropic's messaging is kind of a mess
• The power user community is tiny but gives off early-internet-forum energy. People sharing custom plugins on GitHub like it's 2006

Link: findskill.ai/courses/claude-cowork-essentials/

Happy to answer questions. The file deletion horror stories alone could be their own post.

https://blog.skypilot.co/scaling-autoresearch/

We gave the agent access to our K8s cluster with H100s and H200s and let it provision its own GPUs. Over 8 hours:

• ~910 experiments instead of ~96 sequentially
• Discovered that scaling model width mattered more than all hparam tuning
• Taught itself to exploit heterogeneous hardware: use H200s for validation, screen ideas on H100s

So I made a custom GPT and made a post about it on here a few days ago and already got this back...

Amazing what a 4 year old can come up with lmao and how fun it actually is to play XD was told to make sure to tell everyone NOT to actually eat poop "its just a game" ~ 4 year old Poocasso

I also made a free break down guide of how it was made and how you can make something similar if you are more of build it yourself type!

Recently my desktop broke, so I’ve been using my laptop as my main work machine. The thing is, my laptop is just a basic office-use device.

I’ve noticed that when I use Claude, it feels like it takes longer to complete tasks compared to before. Not sure if this is just in my head or not.

So I’m wondering — does Claude’s performance/speed depend on your local hardware (like GPU, CPU, RAM)? Or should it be the same regardless of what device you're using?

I got laid off on March 2nd. Within 30 minutes I was designing this. Two days later it found the job I'm interviewing for tomorrow.

hire-me-agents is a set of 9 Claude Code slash commands (~3,200 lines of prompt architecture) that automate the entire job search pipeline. No application code — just markdown files orchestrating Claude Code.

What it does:

- /find-me-a-job spawns 3-5 parallel Task agents, each searching different job sources (HN Who's Hiring, We Work Remotely, Google Jobs, etc). They score every match against a 6-dimension rubric and detect which ATS platform each listing uses (Greenhouse vs Workday vs Lever — each gets a different keyword strategy). For every qualifying job, the system generates a tailored resume with ATS-optimized keywords, a cover letter that mirrors the listing's language, full job details, and application instructions. Everything lands in a structured FINAL-REPORT.md with prioritized recommendations.

- /interview-prep does live company research, predicts interview questions with STAR-format answers from your actual resume, then runs interactive mock interviews with real-time scoring.

- /job-stats generates your weekly unemployment certification data with company address lookups — nobody else builds this but it's incredibly useful if you're filing

Across 11 runs it has scanned ~2,900 listings, filtered 96% noise, and surfaced 126 qualified matches — each with its own tailored resume, cover letter, and application package ready to submit.

The whole system is multi-candidate — you can run searches for multiple people with isolated workspaces.

Repo: https://github.com/dominiceloe/hire-me-agents

Happy to answer questions about the architecture or how the multi-agent coordination works. If you're job searching and can't get Claude Code running, DM me — I may be able to help.

I’ve been diving into Claude Code’s to design my own music engine recently, and the results of my investigation are… eye-opening. What started as “listening to some MP3 outputs” turned into a full-on architectural audit.

Here’s what I found:

The Problems We Hear (Literally):

• Pads muddy the harmonic space. Every pad note duplicates the chord root, octave for octave. The result? A wall of sound that fights itself.
• Drums go full machine-gun. Every kick and snare hits predictably every beat, leaving no room to breathe.
• Density overload. Chords, pads, bass, lead, hats — all stacking up to 7–9 simultaneous voices on downbeats. Chaos ensues.

Digging Into the Code:
This isn’t a rendering problem. The engine generates notes that are correct by its own rules, but musically, it’s broken. A few root causes:

1. Model Layer: Notes have no concept of frequency bands or density limits. The engine happily lets pads and chords clash.
2. Profile Layer: Hardcoded drum patterns and velocity ranges enforce rigid, robotic behavior.
3. Generator Layer: Logic bugs — pads copying chord octaves, out-of-scale chord 7ths, duplicate snare hits — compound the mess.

The Deeper, Deeper Root Cause:
It’s not prompts. It’s not rules. It’s how we’ve been thinking about building a music engine:

• We optimized for “task completion” (code runs, tests pass), not musical outcome.
• Each generator layer was built and tested in isolation. Alone, they’re fine. Together, they clash horribly.
• We didn’t listen to the combined output until it was too late — the engine was deaf to its own creations.

Lessons Learned / What Must Change:

• Tests must verify musical sanity, not just structural correctness. Register collisions, density overload, out-of-scale notes — these are audit-level concerns, not “nice to have.”
• Every generator change must consider its impact on the full mix.
• The engine must have permanent safeguards: pre-flight checks, composition quality gates, and updated standing rules to prevent repeating this.

This is a cautionary tale for anyone building AI music systems: green tests ≠ good music. You can generate all the MIDI you want, but without combined-output verification and real “listening,” your engine will happily churn out noise.

I’ve been fixing bugs, updating the rules, and building a full audit system to prevent future failures. But time and time again, new issues surface. What's interesting is that no matter how many fixes, tests and rules I come up with, Claude Code finds another way to let me down. As if on purpose. Before you tell me that my prompts are crap, claude code has already confirmed that the prompts are NOT to blame. Rather, it is it's own fault and flaws causing this.

But I’m curious:

Community Question:
How do you balance mechanical correctness (tests pass) with aesthetic quality in generative music engines? How do we formalize the “listening” step so an AI engine can actually hear what it’s making?

Let’s talk about preventing musical mud before it’s too late.

A few months ago I got tired of re-explaining myself to my AI agent every single session. Context reset. Preferences gone. Tasks forgotten. The agent was smart — but it had no memory and no way to manage its own work over time. So we built the brain layer that was missing.

What we built:

MiniClaw is an open source cognitive architecture layer that sits on top of OpenClaw. It gives your agent persistent memory, an autonomous task brain, and the ability to file its own GitHub issues when it finds bugs.

Free and Open Source: → https://github.com/augmentedmike/miniclaw-os

What's different:
For starters it's a one script install
- Long-term memory — hybrid vector + keyword search (mc-kb). Agent remembers what it learned, what failed, and what you care about — across sessions, weeks, months
- Autonomous kanban — the agent manages its own work queue (mc-board). It creates cards, advances them through review gates, and ships results without being prompted

See screen shot below:

https://preview.redd.it/ue9ae74y11qg1.png?width=1920&format=png&auto=webp&s=f0539af61f61e00864a6b83257fe0c1cffcf4703

- Nightly self-reflection — every night the agent reviews its day, extracts lessons, and writes them to memory (mc-reflection). It gets better over time
- Working memory — per-task scratchpad (mc-memo) that prevents the agent from repeating failed approaches across sessions
- Self-repair — when the agent hits a bug, mc-contribute automatically opens a GitHub issue with full context, then works to fix it. The repo is partially maintained by the agents themselves
- Persistent identity — mc-soul gives the agent a name, personality, and values that load every session. It's not a generic assistant anymore

34+ plugins total. Runs locally on a Mac. Your data never leaves your machine.

How Claude Code actually helped:

Claude Code was a genuine collaborator on the build — not just boilerplate generation. The interesting work was architectural: the hybrid memory retrieval model (when to use vector search vs. keyword, how to rank results across entry types), the board gate system (what conditions a card must meet before it can advance columns), and the mc-contribute autonomous loop (how the agent decides what constitutes a bug worth filing vs. noise).

The crazy thing was we had Claude help us with features we were requesting, but when we gave it the ability to start reviewing the roadmap and come up with suggestions on it's own is when really started to shine. For example, suggesting the self-healing bug fix.

If you look at the commit history you'll see the back-and-forth reflected in the diffs. Claude Code is listed in the README as a collaborator because that's genuinely what it was.

Also, amelia-am1 is a MiniClaw agent using Claude Code

What was missing in OpenClaw that MiniClaw adds:

- Intensive install -> one script to install

- Agent starts cold every session → mc-kb + daily notes loaded on boot. Never starts cold again
- No way to track what the agent is working on → mc-board: full kanban lifecycle the agent manages itself
- Agent repeats the same failed approaches → mc-memo: scratchpad records what not to retry, read at session start
- No continuity of identity → mc-soul: persistent name, personality, values across every session
- Bugs disappear into the void → mc-contribute: agent files its own GitHub issues with full context

Same OpenClaw foundation, with a brain:

Self-hosted, your data, your hardware. Works with Claude(adding the ability to add others as well LLMs as well) Apache 2.0 — open source, always.

Still early. But the memory and board are production-stable and running daily on real workloads.

Hey guys, I’m trying to train a LoRA on Flux dev using Kohya but I’m honestly lost and keep running into issues, I’ve been tweaking configs for a while but it either throws random errors or trains with really bad results like weak likeness and faces drifting or looking off, I’m still pretty new so I probably messed up something basic and I don’t fully understand how to set things like learning rate, network dim/alpha or what settings actually work properly for Flux, I’m also not sure if my dataset or captions are part of the problem, so I was wondering if anyone has a ready to use config for training Flux dev LoRA with Kohya that I can just run without having to figure everything out from scratch, would really appreciate it if you can share one, thanks 🙏

I recently built a small project called XYTE Drop to solve a simple problem I kept facing. Sometimes you just need to send a file quickly without storing it permanently or asking the other person to sign up somewhere. Most tools either feel slow, cluttered, or keep files for longer than needed. So I made a minimal temporary file sharing website where you can upload a file, share the link, and the file gets automatically deleted after it is downloaded. Some current features: Up to 500MB file sharing (working on increasing it to 1GB very soon) End-to-end encrypted transfers Works across Mac, Windows, Android and iOS No signup required Simple and fast UI It’s still early and I’m actively improving it. Would genuinely love feedback from developers and users. Link if you want to try it: https://xyte-drop.vercel.app⁠� Also open to suggestions on features or improvements.

No experience. No budget. No team. Just spent 76 hours researching, building, and shipping. PingBack drafts follow-up messages for freelancers who keep losing deals to silence. 48% of freelancers never follow up at all. That's the problem I'm solving. Day 1. Fingers crossed. 🏓 (drop a comment if you want the link)

🧠 I have ADHD-I myself, and it's my mission to help those who can't afford monthly subscriptions. 💸

✨ Additional features designed primarily to help people with ADHD:

1️⃣ Three-stage Focus Mode: 🎯Cognito Flow Planner

• 🔥 a) Hot start: You return to a task from a month ago, click the note within the task, then enter Focus Mode, and you're in the continuation view with all the necessary data. 🚀
• ☕ b) Warm start: You have less motivation, so you find a task, click the Clock button, and choose how long you want to work on it. At the end, an automatic note linked to the task is created, informing you about the completed session. ⏱️
• 🧊 c) Cold start: When you have zero energy but need to get something done -> you launch Focus Mode -> write absolutely anything. Your first entry creates a task with the same title as in Focus Mode, plus a note with the content you typed. You can continue without exiting or losing data, and every new entry creates another note for the existing task. ✍️

2️⃣ In crucial places, like exiting Focus Mode, you have to wait a few seconds. This helps with ADHD impulsivity and gives you a moment to think if everything is actually okay. 🛑

3️⃣ The app never punishes the user for late or uncompleted tasks. It simply moves them to a "waiting room" where you decide what to do with them. For example, with one click, you can extend the deadline by a week (starting from today). 🛋️

4️⃣ Task notifications 1 hour and 10 minutes beforehand that work without internet or cellular coverage. 🔔

5️⃣ The app is completely offline, so all data is stored exclusively on the user's phone. 🔒

Hello Everyone. For those of you who don't know about QuickV, here is a short introduction.

It is a complete quick Commerce aggregator platform which currently supports - Blinkit, Zepto, Instmart, Bigbasket, Jiomart.

Features of QuickV : 1. Get delivery from all the platforms at one place 2. Compares products in real time 3. Complete cart management inside the app 4. With just one click, you can add all the products to the platform carts. 5. Log into all the platforms from QuickV 6. Order anything from any platform from QuickV.

Problems it solves :

1. Avoid app hopping.
2. Compare prices in realtime
3. Gives you total values of the cart with all the charges
4. Gives you cheapest/fastest/multicart cheapest options
5. Saves you money/time/storage/tracking

Newly added fearures : 1. Now you can get the cheapest/fastest/cheapest (multicart) suggestions. It will compare all combinations from all platforms and suggest you the cheapest/fastest etc.. 2. Get accurate billing details from all the platforms. Includes all the charges like Handling fees, small cart fees, surge charge, delivery charges. 3. All the charges are handled dynamically.

Yesterday I posted Day 1 of this series — the origin story and numbers from a 129-location franchise project. Got some solid feedback, including someone pointing out my mobile layout was broken and my site was crashing. They were right on both counts. Fixed it that night.

Today: how the thing actually gets built, what works, and where it completely falls apart.

The stack:

• Next.js 16 (App Router) — file-based routing, React ecosystem
• Convex — real-time database with WebSocket subscriptions. When a lead's intent score goes from WARM to HOT, every connected client sees it instantly. For speed-to-lead, real-time isn't optional
• Clerk for auth — org management, role-based access, webhook sync to Convex
• Railway for hosting — push to deploy

I picked each piece because it handles a complete domain. I describe features in plain English, Claude Code writes the implementation. If I'm spending time debugging OAuth flows instead of product logic, I've picked the wrong tools.

What works:

Describing features and getting working code in minutes. "When a lead crosses the HOT threshold, send a push notification to the nearest sales rep with tap-to-call and a personalised call script." Schema changes, API endpoints, UI — done. The throughput on product-level code is 10-20x what hiring would give me at this stage.

Where it falls apart — deployment:

Feb 26 was my worst day. 40 commits. Most were fixes. Railway needs standalone Next.js output for Docker. The build succeeded locally but failed in production because of a manifest file Railway couldn't resolve. Spent the entire day on output configs and middleware edge cases.

The AI can't SSH into your container. Can't read runtime logs. When the deploy pipeline is the problem, you're on your own.

The site went down for 4 days. I didn't know. No monitoring, no alerts, and I was testing locally. Found out when I tried to demo to a prospect. The fix was one line. Four days of downtime for a one-line fix.

Auth was rewritten 4 times:

Clerk handles auth, Convex handles the database. They sync via webhook. Simple in theory.

Iteration 1: worked in dev, broke in production. JWT issuer domain was different between Clerk's dev and prod instances.

Iteration 2: fixed JWT. New problem — race condition. User signs up, redirects to onboarding, but the webhook hasn't arrived. Database says "who are you?" two seconds after account creation. First impression destroyed.

Iteration 3: polling. Check for the user record every 500ms for 10 seconds. Worked but felt terrible.

Iteration 4: restructured everything. Onboarding creates the user record using Clerk's session data. Webhook becomes a sync mechanism, not the creation path. Finally solid.

Four iterations. Each half a day. Each time I was sure it was done.

Someone in yesterday's comments asked about schema sprawl — fair question. Started at 20 tables, now at 39. Here's what forced the growth:

• leadEvents: needed every interaction tracked — page views, clicks, form abandonment — to build an accurate intent score. One table became two
• shiftSchedules + centerHours: can't alert reps at 2 AM. Shift-aware routing wasn't optional
• achievements + leaderboardEntries: gamification was scope creep. But 5 reps competing to respond fastest? A leaderboard is the cheapest motivation tool there is
• boostSites: AI scans a prospect's website and shows exactly what SignalSprint would add. Became the best sales tool in the stack

Every table exists because something broke without it. But yeah, 39 is a lot. Some of it could probably be consolidated.

What I'd tell anyone building with AI tools:

1. Pick a stack where each piece owns a domain. Don't build your own auth or real-time layer
2. Test everything. Click every button. Try to break it. The AI writes code that looks right and breaks in production
3. Deployment is where AI help drops to near zero. Budget 3x the time
4. One person flagging your mobile layout is worth more than a week of building features. Ship early, take the punches

Tomorrow: the rebrand, the Stripe bugs, and the emotional part nobody posts about.

TL;DR: Building with Claude Code. 391 commits, 39 tables. AI is 10-20x faster on product code. Useless for deployment. Auth rewrote 4 times. Site down 4 days and I didn't know. Someone told me my mobile layout was broken yesterday — they were right. Ship early, fix fast.

I never really got into the LLM hype. It always felt kind of overblown and driven by big tech firms trying to scam investors. Sure, I used online chat windows, and from time to time I was actually impressed with their content. But this feels different.

I set up qwen2.5 32B on a machine with a Blackwell h600 in our lab (expensive toy, I know). The feeling when Text appeared in the terminal, actual, hard-earned text and not chatgpt Fastfood, ... Wow. I can only imagine what the developers of early models must have felt when it started working.

Anyway, in a few weeks people in my lab want to use the compute for data-anotation and stuff, but right now I'm free to play around with it. Any cool ideas for stuff I should try?

Last year I spent 6 months building a tool I was convinced people needed. I planned features, designed the UI, wrote thousands of lines of code. Launched it proudly. Got maybe 10 signups in the first month. Most never came back.

The mistake was obvious in hindsight: I built what I thought people wanted instead of asking them first.

This time around I'm doing it differently. Before writing a single line of code, I did three things that changed everything.

First, I talked to 30 potential users and asked about their problems. Not "would you use this tool" because everyone says yes to that. Instead I asked "what's the most frustrating part of your workflow right now?" The answers surprised me and pointed in a completely different direction than my original idea.

Second, I created a simple landing page describing the solution and ran a small ad budget to see if people would even click. Cost me about $50 and gave me real data instead of assumptions.

Third, I built the ugliest possible MVP that solved one core problem. No fancy design, no extra features. Just the one thing people said they needed. Released it to the 30 people I'd talked to.

Result: 22 of them used it in the first week. 15 were still using it after a month. That's when I knew it was worth building properly.

The lesson: code is the most expensive way to validate an idea. Conversations are free. Landing pages are cheap. Build the minimum viable version only after you have evidence people actually want it.

Anyone else learn this the hard way?

Google just announced spend caps for the Gemini API, but their own docs note enforcement can lag by ~10 minutes.

They also explicitly say users are still responsible for any overages during that window.

If you're running autonomous agents, that's a real problem.

10 minutes is more than enough for a bad loop, retry storm, or tool misfire to burn serious money.

And the worst part is that nothing visibly "breaks":
no hard stop, no immediate failure — just a bill later.

Update: Google officially confirmed this in a developer email today.

"the system will pause requests within approximately 10 minutes. You are responsible for any overages incurred during this window."

This is in their official April 1, 2026 billing changes announcement.

This is why alerts and soft caps don't feel sufficient for agent workloads.

How are people here enforcing actual hard limits for autonomous agents?

Infra layer?
Proxy/gateway?
Per-task budget locks?

A lot of AI generated stuff often comes off as… well, loose or kind of lazy. It's not that it's intentionally bad, but just copy-pasting that raw output can really chip away at your authority with an audience; it kind of implies their time isn't worth a proper human touch.

So, for a while now, I’ve been using this private "humanizer" for my own content. It’s not some super complicated thing, more like a simple wrapper, really. The secret sauce, if there is one, is all in the prompt engineering.

Looking at the numbers: it’s hit about 99.1% efficiency across over 500 posts, which is pretty wild. That translates to saving me like 3-5 minutes of fiddling with each post. I actually just spent about an hour last night sprucing up the UI to get it ready for the public, and it cost me absolutely nothing to build. It's just a tool, you know, for other builders.

Being a solo builder, I just don't have time for those long editing sessions. I needed something surgical, something that could make text sound genuinely human, not like some marketing bot. I approached the prompt engineering almost like crafting a unique DNA profile, trying to make it defy that typical, average AI output.

It's actually live now, and I'm genuinely curious about it. I wonder if this "human" output might feel a bit too… punchy for something more academic. I really built it with builders and creators in mind, so if you try it for, say, technical documentation, I'd love to hear where it might not quite fit.

I’m keeping it free, forever. It's for anyone who dreads the blank page but refuses to put out something half-baked. you can find try it on:sandrobuilds.com/tools/humanizer

Example: https://imgur.com/a/eAeRluM

Hey guys!

I am sorry but i just checked different models (Qwen 3.59b, llama3.1...) and most of them are very useless, stupid dialogues (using prompt) and web mcp but nothing.. any alternative after google plan cut?

Thank you

Chess Scout is a small tool I built that analyzes a player’s recent games and tries to generate a scouting report on how they actually play.

It looks at patterns across hundreds of games, including things like opening preferences, aggression vs positional play, time management, and performance across different phases of the game. Based on that, it also generates a simple “how to play against them” guide highlighting potential weaknesses.

The idea is to turn raw game history into something more actionable than just ratings or accuracy scores.

It also generates funny data like at which time of the day you play the best and also how much chaos you enjoy on the board.

Check it out at

Chess Scout

https://reddit.com/link/1ry6jk4/video/6gmoxfl9c1qg1/player

Hi everyone,

I recently built a side project called Savemelin.

The idea came from a problem I kept running into while shopping online in Argentina:
the same product can vary 30–40% in price depending on the store, and comparing prices across sites is pretty annoying.

So I built a tool that:

• Lets you search a product
• Shows the same product (or similar ones) across different stores
• Orders them from cheapest to most expensive
• Shows price in USD
• Includes price history
• Lets users follow products and get alerts when prices drop
• Has a dashboard to track products you're interested in

Right now it's focused only on Argentina, since the market here has some unique issues (marketplace commissions, inconsistent pricing, etc.).

So far I have:

• ~2400 visits
• ~70 users signed up
• Early feedback that the tool is useful

Now I'm trying to figure out the best monetization strategy.

Current ideas:

1. Affiliate links
If a user clicks a product and buys it from the store (MercadoLibre or other stores), I earn a small commission.

2. Cheap premium plan
Something like $2–$4/month that could include things like:

• advanced price alerts
• more tracked products
• better deal detection
• maybe historical price analytics

But I'm not sure if this type of product should rely mostly on affiliate revenue or subscriptions.

So I’d love some feedback:

• What monetization model would you prioritize for a tool like this?
• Have any of you built price comparison tools before?
• Do affiliate models work well at small scale?
• Any way this project could scale or get frequent users?

If anyone wants to try it or give feedback, I’d really appreciate it, but consider it is for argentinians.

Thanks!

I’ve been experimenting with a mix of Claude and Codex in my dev workflow and trying to move away from just “vibe coding” into something more structured.

My Current flow:

-Use Claude to think through the feature / explore the problem

-Write a rough spec (what it should do, constraints, edge cases)

-Break it into smaller steps / map how things connect across files

-Use Codex for implementation

-Review + refactor manually

This already feels a lot better than just jumping into coding.

One thing I’ve noticed is that Claude is really strong at reasoning and structuring, while Codex works much better once everything is clearly defined. I’ve been also trying to be more explicit about flows between files and components using tools like Traycer, it does help with multi-file clarity, orchestration and architectural planning.

Still, a few things feel off:

-multi-file changes can still get messy

-not always sure if my spec is “good enough”

-still doing a fair amount of manual verification

Feels like I’m close to a solid workflow, but something is missing. Please suggest what I am missing.

This is an automatic post triggered within 2 minutes of an official Claude system status update.

Incident: Elevated errors on Claude Opus 4.6

Check on progress and whether or not the incident has been resolved yet here : https://status.claude.com/incidents/bf1hsq5gbm9b

Also check the Performance Megathread to see what others are reporting : https://www.reddit.com/r/ClaudeAI/comments/1pygdbz/usage_limits_bugs_and_performance_discussion/

My Downloads folder was a disaster. Hundreds of files, no idea where half of them came from, duplicates everywhere. I kept thinking "there has to be a better way to deal with this" — so I built one.

Download Inbox sits on top of your browser downloads and turns them into an inbox you can actually work through. You can:

• See every new download in a focused inbox view
• Search and filter by file type, source, or tags
• Spot duplicates (exact matches, probable dupes, and likely new versions)
• Get smart filename suggestions so you stop having files called "document(7).pdf"
• Reopen the page a file came from — super useful when you forget where you got something
• Set up routing rules to auto-organize files

Built it mainly for myself — I download a ton of stuff for work and research — but figured others might have the same problem.

Free to use. There's a Pro tier for bulk rename, routing rules, and export if you need it.

Would love feedback. What's the first thing you'd want in a download manager like this?

Link: https://chromewebstore.google.com/detail/download-inbox/ibclcjenmhkbcbjanepcamgpanfbhkpl

I've been running open-source models in production and finally sat down to do a proper side-by-side comparison. I picked 3 open-source models and 2 proprietary — the same 5 in every benchmark, no cherry-picking.

Open-source: DeepSeek V3.2, DeepSeek R1, Kimi K2.5 Proprietary: Claude Opus 4.6, GPT-5.4

Here's what the numbers say.

Code: SWE-bench Verified (% resolved)

Proprietary wins. Opus and GPT-5.4 lead at ~80%. Kimi is 4 points behind. R1 is a reasoning model, not optimized for code.

Reasoning: Humanity's Last Exam (%)

Open-source wins decisively. R1 hits 50.2% with pure chain-of-thought reasoning. Kimi matches it with tool-use enabled (*without tools: 31.5%). Both beat Opus by 10+ points.

Knowledge: MMLU-Pro (%)

GPT-5.4 leads narrowly but all three open-source models beat Opus. Total spread is only 6.5 points — this benchmark is nearly saturated.

Speed: output tokens per second

Kimi at 334 tok/s is 4x faster than GPT-5.4 and 7x faster than Opus. R1 is slowest (expected — reasoning tokens).

Latency: time to first token

Kimi responds 8x faster than Opus. Even V3.2 beats both proprietary models.

The scorecard

Open-source wins 3 out of 5. Proprietary leads Code (by 4 pts) and Knowledge (by 1.4 pts). Open-source leads Reasoning (+8.6 pts), Speed (4.3x), and Latency (3x).

Kimi K2.5 is top-2 on every single metric.

Note: Kimi K2.5's HLE score (50.2%) uses tool-augmented mode. Without tools: 31.5%. R1's 50.2% is pure chain-of-thought without tools.

What "production-ready" means

1. Reliable. Consistent quality across thousands of requests.
2. Fast. 334 tok/s and 0.31s TTFT on Kimi K2.5.
3. Capable. Within 4 points of Opus on code. Ahead on reasoning.
4. Predictable. Versioned models that don't change without warning.

That last point is underrated. Proprietary models change under you — fine one day, different behavior the next, no changelog. Open-source models are versioned. DeepSeek V3.2 behaves the same tomorrow as today. You choose when to upgrade.

Sources: Artificial Analysis | SWE-bench | Kimi K2.5 | DeepSeek V3.2 | MMLU-Pro | HLE

Hey guys,

I’ve seen so many people feeling lost because they think they need a 4-year CS degree to work with AI in 2026. Honestly? Most of the pros I know now are focusing on Local LLMs (Ollama/DeepSeek) and Agentic Workflows rather than heavy coding.

I put together a deep-dive roadmap (about 1,500 words) on how to go from zero to an "AI Solutions Architect" mindset by focusing on privacy, local models, and multi-agent systems. It’s written for anyone who wants to build real-world AI efficiency without the academic fluff.

Just wanted to share my perspective on how the industry has shifted toward Sovereign AI.

Not asking about specs or benchmarks – more about real-world experience.

If you're running workloads on H100s (cloud, on-prem, or rented clusters), what’s actually been painful?

Things I keep hearing from people:

•multi-node performance randomly breaking

•training runs behaving differently with same setup

•GPU availability / waitlists

•cost unpredictability

•setup / CUDA / NCCL issues

•clusters failing mid-run

Curious what’s been the most frustrating for you personally?

Also – what do you wish providers actually fixed but nobody does?

Been running Qwen2.5 Coder 32B at Q8 in LM Studio on M4 Pro Max 128GB and honestly its been a game changer for small-medium codebases. You still have to guide it — give it context, tell it what to focus on. But once you do that it picks up patterns that would take me 20 minutes to spot manually. Not too sure how well it scales past 10k lines of context though. Anyone tried different quant levels specifically for code review? Curious which is the sweet spot before quality drops off noticeably.

I spend way too much time rewording prompts to see which version gives better results. I figured there has to be a lazier way to do this, so I wrote a Python script that does it for me.

You make a YAML file listing your prompt variants and which models to test. The tool runs every prompt on every model, then scores the outputs automatically. I tested it with a code review task, 3 different prompt styles across gpt-5-mini and claude-sonnet-4.

Here's what my config looked like:

task: code_review input: | def get_user_data(user_id): conn = sqlite3.connect("users.db") cursor = conn.cursor() query = f"SELECT * FROM users WHERE id = {user_id}" cursor.execute(query) result = cursor.fetchone() return result models: - openai/gpt-5-mini - anthropic/claude-sonnet-4 prompts: - "Review this code and list any bugs or security issues:" - "What's wrong with this code?" - "Improve this code and explain your changes:" scoring: criteria: [correctness, thoroughness, clarity] judge_models: [openai/gpt-5-mini, anthropic/claude-sonnet-4] exclude_self_judge: true 

Scoring works in two parts. There's an AI judge (another model rates the output 1-10 on criteria you define) and some rule-based checks (length, structure, repetition, formatting). The scores get combined into a final number and you get a nice table in the terminal showing which prompt + model combo scored highest.

The thing I found interesting: "What's wrong with this code?" scored lower than the more specific prompts on both models. The casual question got shorter, vaguer answers. "Review this code and list any bugs or security issues" made both models actually walk through the SQL injection problem, the missing connection close, and the bare SELECT *. The gap was bigger than I expected. Both models caught the SQL injection with all three prompts, but the specific prompt made them more thorough about the other issues.

Another thing: I have the tool set up so models don't judge their own outputs (there's a flag for that). Without it, each model would give itself higher scores, which kind of defeats the purpose.

Some other stuff it does: you can skip the AI scoring entirely with --no-ai-scoring if you just want the rule-based scores (faster and free), override models from the command line with --models, and export results to JSON.

Works with any OpenAI-compatible API. I use an aggregator platform called ZenMux that gives me 100+ models under one API key, which is perfect for this since I need to test across a bunch of different models without managing separate accounts. Just two env vars to set.

Github Repo: superzane477/prompt-tuner

Next thing I want to try is running it on translation prompts to see if the same "specific beats casual" pattern holds there too.

Hey everyone,

I’m a software engineer and I spend way too much time camping and hiking around Upstate NY when the weather permits. I got fed up with trying to remember what campsites were were worth reserving, so I spent the off-season building my very first mobile app to fix that problem. Google just approved it for production yesterday, so now I am telling people about it.

It’s called SiteQuest (sitequest.me).

The idea is simple: you go tour a campground, and instead of trying to remember which sites were actually good, you log them. I built in a tool that uses the phone’s gyro/accelerometer to check the actual pitch and roll of the spot, plus check boxes to log Starlink suitability and phone signal strength. It also has a "quick scout" mode for logging dispersed campsites out in the wild or stealth sites if you like stealth camping or van life.

I’m a hammock camper with kids, so the main "must-have" for me was a way to log tree spacing so I don't show up and realize we have nowhere to hang.

If you want to know anything about the stack, I built it using React Native/Expo for the front end, sqlite for local saving, and Supabase for cloud saving and account information.

It’s Android only for now. There are zero ads and there never will be. There is a pro mode for a one time fee. I am sick of all the subscriptions these days, so that is a model I wanted to stay away from. The app is perfectly usable for free. I only collect necessary data for tying your account to your data and tracking who buys pro. I am not, nor will I ever be interested in collecting unnecessary data or selling what I do collect to anyone.

If you’re a camper or even an app developer who wants to give it a test, I’d love to hear any feedback you may have.

I keep reading about people successfully using Claude via MCP but I can’t for the life of me work out how people do it.

Has anyone managed to get it working via Proxmox, I can’t seem to find any walkthroughs online about how to do this. The only ones I’ve seen use mac/windows for client which I guess I could do but trying to keep it all on the server.

The only other thing I saw washing getting the Claude CLI as an add on but I could never get past the authorise screen for it.

Cheers.

Over the last year I have tested some ways to mix AI + LinkedIn automation, and this is the only setup that is both safe and gives me consistent 20-30% reply rates on cold outreach. You can copy the structure and adapt it to your niche.

So here is the workflow step by step:

• define the campaign goal and lead type first (who you target, what you offer, what success looks like)
• build a clean lead list with enough context: headline, role, company size, location, industry, recent activity, and any trigger (job change, funding, hiring, tech stack)
• create 3-5 message frameworks manually before touching AI (connect request, first message, soft follow-up, value drop, bump)
• turn each framework into an AI prompt template with placeholders like [ROLE], [COMPANY], [TRIGGER], [PAIN], [OFFER OUTCOME]. keep the AI tone rules strict and short
• batch-generate messages from your lead list, always include a safety rule such as “no hype, no exaggerated claims, max 60 words”
• manually review a sample (10-20%) and fix anything off-brand; if you see repeated issues, adjust the prompt, not the messages
• upload the final messages into your outreach tool as custom variables and run the sequence with daily limits, random delays, and at least 2-3 text variations per step

And a few extra details that helped a lot:

• use different prompt templates for different segments, for example founders vs hr vs engineers, instead of one generic prompt for everybody
• reference one real detail from the profile or company in the opener, then shift quickly to a clear, low-friction call to action like “open to a quick look at X” instead of pushing for a call immediately
• aim for 3-4 touchpoints over 10-14 days, no more. if they do not respond after that, move them to a different nurture channel
• track numbers per step, not just overall: connection accept rate, first reply rate, positive reply rate. if your accept rate is low the problem is in targeting
• when scaling, think more segments, not more volume so you stay under the radar and keep relevance high
  

If anyone wants, I can also share the exact fields I keep in my lead spreadsheet and how I map them into the AI prompts so the messages stay natural instead of sounding like filler text.

Tried to move away from a traditional portfolio and make it feel like a real desktop experience with interactive windows and snappy interactions.

Would really appreciate any feedback on UX, performance, or overall feel.

Been building with AI tools (Claude Code, Cursor, Bolt, Lovable) for a while now. The pattern is always the same: you get 80% done in an hour, then spend days stuck on some auth bug or deploy error the AI keeps making worse.

I talked to enough people hitting the same wall that I built VibeFix. You post your bug as a bounty (free to post right now), a developer picks it up and fixes it. Structured template so they get your stack, expected vs actual behavior, steps to reproduce.

It also has an MCP server so you can post bounties directly from Cursor or Claude Code without leaving your editor.

What's live right now:

- Free bounty posting with structured bug templates

- Developer applications and submission flow

- Private jobs with NDA support

- XP and reputation system for developers

- MCP server for Cursor/Claude Code/Windsurf

- Chrome extension that captures JS errors and pre-fills bounty posts

- Website diagnostic scanner (free Lighthouse + error detection)

Still early. Everything is free right now.

Site: vibefix.co

MCP: npmjs.com/package/@vibefix/mcp

Would love feedback on anything, especially from people who've been stuck on a vibe coded bug and given up.

I've been using CoWork as I thought it was just a different wrapper, but I'm confused by the Code tab within the app (not in the terminal). Are there structural advantages of Code to CoWork? I am not a big coder, but it seems like everyone likes Code.

I thought you could do both documents/knowledge work and coding in either, but am I wrong. Is there a difference between skills/connectors in CoWork and plugins in Code?

Is anyone else experiencing really laggy performance of Alexa commands and/or delayed or missing playback of TTS?

This seems to have started this month and gotten acutely worse after 3.2. Don't know if this is something about the Alexa integration or Amazon itself. Alexa seems to respond OK to non-HA commands like adding things to a shopping list.

The things have been pestering me to upgrade to Alexa+ (AI) every fourth or fifth time I ask it for something and I always say no.

My internet connection is running normally. I've rebooted the Echo devices as well.

Using Alexa for TTS output I'm getting really tired of "Sorry, I can't access the Simon Says..." thing. It used to be 1 out of 10 did that, but now half or more fail and sometimes it plays nothing at all.

This is an automatic post triggered within 2 minutes of an official Claude system status update.

Incident: Elevated errors on Claude Opus 4.6

Check on progress and whether or not the incident has been resolved yet here : https://status.claude.com/incidents/bf1hsq5gbm9b

Also check the Performance Megathread to see what others are reporting : https://www.reddit.com/r/ClaudeAI/comments/1pygdbz/usage_limits_bugs_and_performance_discussion/

Beyond achieving state-of-the-art (SOTA) performance in standard multilingual document parsing among models of comparable size, dots.mocr excels at converting structured graphics (e.g., charts, UI layouts, scientific figures and etc.) directly into SVG code. Its core capabilities encompass grounding, recognition, semantic understanding, and interactive dialogue.

With AI tools and modern frameworks, building products has never been faster. But one thing that keeps slowing us down is messaging especially SMS. You can build the feature in hours, but getting it approved and working reliably takes way longer.

Anyone else running into this?

Open Source Release

I have released three large software systems that I have been developing privately over the past several years. These projects were built as a solo effort, outside of institutional or commercial backing, and are now being made available in the interest of transparency, preservation, and potential collaboration.

All three platforms are real, deployable systems. They install via Docker, Helm, or Kubernetes, start successfully, and produce observable results. They are currently running on cloud infrastructure. However, they should be considered unfinished foundations rather than polished products.

The ecosystem totals roughly 1.5 million lines of code.

The Platforms

ASE — Autonomous Software Engineering System

ASE is a closed-loop code creation, monitoring, and self-improving platform designed to automate parts of the software development lifecycle.

It attempts to:

• Produce software artifacts from high-level tasks
• Monitor the results of what it creates
• Evaluate outcomes
• Feed corrections back into the process
• Iterate over time

ASE runs today, but the agents require tuning, some features remain incomplete, and output quality varies depending on configuration.

VulcanAMI — Transformer / Neuro-Symbolic Hybrid AI Platform

Vulcan is an AI system built around a hybrid architecture combining transformer-based language modeling with structured reasoning and control mechanisms.

The intent is to address limitations of purely statistical language models by incorporating symbolic components, orchestration logic, and system-level governance.

The system deploys and operates, but reliable transformer integration remains a major engineering challenge, and significant work is needed before it could be considered robust.

FEMS — Finite Enormity Engine

Practical Multiverse Simulation Platform

FEMS is a computational platform for large-scale scenario exploration through multiverse simulation, counterfactual analysis, and causal modeling.

It is intended as a practical implementation of techniques that are often confined to research environments.

The platform runs and produces results, but the models and parameters require expert mathematical tuning. It should not be treated as a validated scientific tool in its current state.

Current Status

All systems are:

• Deployable
• Operational
• Complex
• Incomplete

Known limitations include:

• Rough user experience
• Incomplete documentation in some areas
• Limited formal testing compared to production software
• Architectural decisions driven by feasibility rather than polish
• Areas requiring specialist expertise for refinement
• Security hardening not yet comprehensive

Bugs are present.

Why Release Now

These projects have reached a point where further progress would benefit from outside perspectives and expertise. As a solo developer, I do not have the resources to fully mature systems of this scope.

The release is not tied to a commercial product, funding round, or institutional program. It is simply an opening of work that exists and runs, but is unfinished.

About Me

My name is Brian D. Anderson and I am not a traditional software engineer.

My primary career has been as a fantasy author. I am self-taught and began learning software systems later in life and built these these platforms independently, working on consumer hardware without a team, corporate sponsorship, or academic affiliation.

This background will understandably create skepticism. It should also explain the nature of the work: ambitious in scope, uneven in polish, and driven by persistence rather than formal process.

The systems were built because I wanted them to exist, not because there was a business plan or institutional mandate behind them.

What This Release Is — and Is Not

This is:

• A set of deployable foundations
• A snapshot of ongoing independent work
• An invitation for exploration and critique
• A record of what has been built so far

This is not:

• A finished product suite
• A turnkey solution for any domain
• A claim of breakthrough performance
• A guarantee of support or roadmap

For Those Who Explore the Code

Please assume:

• Some components are over-engineered while others are under-developed
• Naming conventions may be inconsistent
• Internal knowledge is not fully externalized
• Improvements are possible in many directions

If you find parts that are useful, interesting, or worth improving, you are free to build on them under the terms of the license.

In Closing

This release is offered as-is, without expectations.

The systems exist. They run. They are unfinished.

If they are useful to someone else, that is enough.

— Brian D. Anderson

https://github.com/musicmonk42/The_Code_Factory_Working_V2.git
https://github.com/musicmonk42/VulcanAMI_LLM.git
https://github.com/musicmonk42/FEMS.git

So, I’m not a coder, but coded my way through a project aligned to my very-not-IT-field. So bare with my amateurism.

I do love Claude in that it’s way better than all other LLM’s I’ve used so far. Now I use it for all kinds of stuff, like generating pdf’s for handouts and pitches (what I’m working on now).

However… if I need to start a new chat and ask them to continue on work done in another chat, he always seems to forget a lot of what we’re doing. I ask him to update memory, I work in projects, ask him to make handovers to start a new chat when it’s almost hit his length etc but I just keep getting stuck and frustrated with this issue that arises with every new chat.

Do you have any idea where I’m going wrong and what I could do to improve? Now by the time I have him back up to speed, I’ve spent hours and tokens and the chat hits his length again.

I kept running into the same situation:

I had a CSV file and just wanted to quickly visualize it.

But every time it turned into: - opening Excel - fixing columns - or writing a quick Python script

Felt like overkill for something simple.

So I built a small tool where you can: paste/upload CSV → instantly get a graph

No login, no setup.

Still improving it, so would love feedback: What would make something like this actually useful for you?

Link: https://plotiq-web.web.app/

For decades, the standard formula for financial success was the same: go to college, get a degree, and land a prestigious white-collar job—probably a lawyer, consultant, or investment banker.

But entrepreneur and author Daniel Priestley is sounding the alarm on a major job-market shift. He suggests the traditional hierarchy of labor (white-collar over blue-collar) is actually flipping.

Priestley, founder and CEO of Dent Global, an entrepreneur accelerator, said he’s observed that the nature of the economy is changing so rapidly that he envisions a future in which “plumbers regularly earn more than lawyers,” as blue-collar roles are elevated while professional services face unprecedented disruption from AI.

“I have never experienced what we’re experiencing right now,” Priestley said during a recent appearance on the Diary of a CEO podcast.

Read more: https://fortune.com/2026/03/19/plumbers-outearning-lawyers-daniel-priestley-blue-collar-vs-white-collar-american-dream/

Video description:

This video really doesn't do the program justice; it's my crown jewel as of right now. What started off as me just tinkering with learning machine learning and AI and such snowballed into a full program that captures the likeness of our favorite computer from Danganronpa. I'll most likely make a version of it with its own coat of paint down the line so that it doesn't wholly rely on a familiar face and can instead be its own independent thing, but that's a problem for future me.

Try out the program: https://alter-ego-pwa.vercel.app/

Desktop app download: COMING SOON

DISCLAIMER: THIS PROGRAM USES EXTERNAL API KEYS AND REQUIRES KNOWLEDGE OF HOW TO OBTAIN AND SET UP SAID API KEYS. EXTERNAL COSTS ARE REQUIRED TO USE THIS SOFTWARE. I AM NOT LIABLE FOR ANYTHING THAT MAY OCCUR WITH SAID API KEYS.

Essentially what it says in the title. I am working on some backend signal processing for a company that have given me access to a fairly large library of proprietary C code to make use of, and avoid duplicating existing code. With it being proprietary, I can't get Claude on the case to help me rummage through it all to search out useful snippets to knit together.

I've played around with local models a bit for general assistant tasks, but haven't delved in to using them for coding as of yet. My machine is an M3 Macbook pro with 18GB unified memory and my go to general use model is Qwen3.5 9B Q4_k_m which runs well but is a little slow on my machine so I wouldn't want to push it much larger than that.

What small local models do you recommend currently for coding tasks and do you have any recommendations on the best way to integrate local models into a coding workflow?

I've recently discovered HA and I've been setting up everything I currently have on there.

One issue I'm having is setting up my Hive Heating. It just hangs on the login screen and does not proceed any further (spinning icon when pressing confirm). I've posted the log below. Does anyone know what could be happening please?

Log details (ERROR) Logger: homeassistant.config_entries Source: config_entries.py:769 First occurred: 18 March 2026 at 19:24:40 (2 occurrences) Last logged: 16:50:31

Setup of config entry '@gmail.com' for hive integration cancelled Traceback (most recent call last): File "/usr/local/lib/python3.14/site-packages/apyhiveapi/api/hive_auth_async.py", line 624, in refresh_token result = await self.loop.run_in_executor( ...<7 lines>... ) ^ File "/usr/local/lib/python3.14/concurrent/futures/thread.py", line 86, in run result = ctx.run(self.task) File "/usr/local/lib/python3.14/concurrent/futures/thread.py", line 73, in run return fn(args, *kwargs) File "/usr/local/lib/python3.14/site-packages/botocore/client.py", line 569, in _api_call return self._make_api_call(operation_name, kwargs) ~~~~~~~~~~~~~~~~~~~ File "/usr/local/lib/python3.14/site-packages/botocore/client.py", line 1023, in _make_api_call raise error_class(parsed_response, operation_name) botocore.errorfactory.NotAuthorizedException: An error occurred (NotAuthorizedException) when calling the InitiateAuth operation: Invalid Refresh Token.

The above exception was the direct cause of the following exception:

Traceback (most recent call last): File "/usr/local/lib/python3.14/site-packages/apyhiveapi/session.py", line 462, in hiveRefreshTokens result = await self.auth.refresh_token( self.tokens.tokenData["refreshToken"] ) ^ File "/usr/local/lib/python3.14/site-packages/apyhiveapi/api/hive_auth_async.py", line 642, in refresh_token raise HiveRefreshTokenExpired from err apyhiveapi.helper.hive_exceptions.HiveRefreshTokenExpired

During handling of the above exception, another exception occurred:

Traceback (most recent call last): File "/usr/src/homeassistant/homeassistant/configentries.py", line 769, in __async_setup_with_context result = await component.async_setup_entry(hass, self) File "/usr/src/homeassistant/homeassistant/components/hive/init.py", line 42, in async_setup_entry devices = await hive.session.startSession(hive_config) File "/usr/local/lib/python3.14/site-packages/apyhiveapi/session.py", line 783, in startSession await self.getDevices("No_ID") File "/usr/local/lib/python3.14/site-packages/apyhiveapi/session.py", line 632, in getDevices await self.hiveRefreshTokens() File "/usr/local/lib/python3.14/site-packages/apyhiveapi/session.py", line 486, in hiveRefreshTokens await self._retryDeviceLogin() File "/usr/local/lib/python3.14/site-packages/apyhiveapi/session.py", line 417, in _retryDeviceLogin await self.hiveRefreshTokens(force_refresh=True) File "/usr/local/lib/python3.14/site-packages/apyhiveapi/session.py", line 443, in hiveRefreshTokens async with self._refreshLock: File "/usr/local/lib/python3.14/asyncio/locks.py", line 14, in __aenter_ await self.acquire() File "/usr/local/lib/python3.14/asyncio/locks.py", line 110, in acquire await fut asyncio.exceptions.CancelledError: Global task timeout: Bootstrap stage 2 timeout

The thing that brought me to LLMs 3 years ago, was the ability to obtain custom-fit knowledge based on my context, avoiding the pathetic signal-to-noise ratio that the search engines bring.

The main focus now even with the huge models, is to make them as agentic as possible, and I can't help but think that, with the limited number of params, focusing on agentic task will surely degrade model's performance on other tasks.

Are there any LLM labs focusing on training a simple stupid model that has as much knowledge as possible? Basically an offline omniscient wikipedia alternative?

How it works:

• Install the extension, upload your resume once
• Browse jobs on LinkedIn/any other job board — it auto-detects the job listing
• Shows a match grade (A+ to F) with every requirement classified: covered, bridgeable, or genuine gap
• Generates a refactored resume for that specific role.
• You accept or reject every change
• Exports as ATS-friendly DOCX

42-second demo: https://www.youtube.com/watch?v=xZIJPtTmizo

Landing page: https://ankitmandal.github.io/fitted-landing/

Tech stack: React + TypeScript extension, Hono server on Railway,

Groq for LLM inference (4-stage pipeline), Firebase for auth.

Built solo .

Would love feedback, especially on the refactoring quality.

That's the part I've been iterating on the most.

Hey everyone, I just released a Chrome extension called YTKeys.

It adds extra keyboard shortcuts to YouTube — things like liking videos, subscribing, skipping ads, switching theater mode, and even navigating Shorts — all from the keyboard.

You can also remap the keys to whatever you prefer.

I built it mainly because I wanted to use YouTube without relying on the mouse so much.

Would love to hear what shortcuts you think YouTube is missing or what you'd want to control from the keyboard.

https://preview.redd.it/9yfc22x7x0qg1.png?width=1400&format=png&auto=webp&s=3d992e53a93f24cfbd715b0081a82667c05b9fa4

In my case, I already had decent context in claude.md, but I wasn’t sure:

Should I rely on “clear context” to reset and let Claude re-interpret everything cleanly
Or go with the second option and trust the existing context + plan as-is

I just received three emails saying I bought for myself a gift of one month of Claude Max 20x. I have until 19th March (today) to redeem this gift. I received three copies of this email - from three different senders.

The sender was “no-reply-ygah3qfsdgqhed_5qmdkqg@mail.anthropic.com” - does this look like a legit Anthropic email? Most concerning is that I also got receipts saying they billed £180 of me for this gift. The card details in the receipt match, but I can’t check whether any money was taken yet.

I haven’t pressed the redeem link yet but it seems kinda fishy.

Hi everyone,

I’ve been working on a problem that’s been driving me crazy.

We’ve all seen agents like OpenClaw or various GPT-wrappers. They’re great for "chatting," but when you ask them to build a complex automation, they usually just write a throwaway unsecure Python script or such.

It’s a black box. You can’t audit it, you can’t version it, and you certainly can’t trust it for production.

So I built Yagr (Your Agent Grounded in Reality).

The concept: Instead of "dreaming" code, Yagr uses a strict TypeScript ontology to architect real n8n workflows.

How it works:

1. It’s powered by my engine n8n-as-code (which some of you might know, it hit 500+ stars recently).
2. Every n8n node is mapped as a strict TS decorator.
3. When you give Yagr an intent, it doesn't "guess". It plans against the actual node definitions.
4. It generates a valid, clean workflow that you can immediately see, edit, and push to Git.

Why I think this matters: The workflow becomes the "durable memory and muscle" of the agent. It’s not just a chat history; it’s a deployable asset.

It’s 100% open-source. I’d love to get some feedback from the n8n power users here. Does this solve the "AI hallucination" pain point for you too?

Repo here: EtienneLescot/yagr: (Y)our (A)gent (G)rounded in (R)eality
Docs: Yagr - (Y)our (A)gent (G)rounded in (R)eality | Yagr

Looking forward to hearing what you think!

I kept hitting the same problem:

Write Python → profile → find hot loop → rewrite in C → fight ctypes → debug pointers → finally get 5× speedup. Then repeat next week.

So I built Eä.

Eä is a compiler for SIMD kernels:

- write a small .ea file

- run one command

- call it from Python like a normal function

But it runs at native vectorized speed.

Example:

import ea kernel = ea.load("fma.ea") result = kernel.fma_f32x8(a, b, c, out) # 6.6× faster than NumPy Benchmarks are from a fairly simple setup, but I tried to keep things fair and reproducible. 

No ctypes. No header files. No build system.

The compiler generates:

- shared library

- Python wrapper

- (also Rust, C++, PyTorch, CMake bindings)

Targets:

- x86-64 (AVX2 / AVX-512)

- AArch64 (NEON)

Whole compiler:

- ~12k lines of Rust

- 475 tests

The main idea:

the compiler handles all the "glue code" so you can focus only on the kernel.

That turned out to matter more than SIMD itself.

I'm not a compiler engineer. I don't have a CS degree. I'm the kind of person who has ideas and wants to see if they work.

What changed is the tooling. I built Eä with the help of AI models. Claude for the heavy lifting, my own judgment for the architecture and design decisions. The hard rules came from me (learned the painful way from the first attempt). The implementation speed came from having a capable coding assistant.

---

Full write-up (design, desugaring, binding generation, etc):

https://petlukk.github.io/eacompute/blog/12k-lines-of-rust.html

I have used it for a few years now, and it's been very long-winded lately. I keep getting absolute novels back, and I have to keep reminding it to be a bit more concise.

I don't want to manually limit it, but it's a lot. lol

Hello.
I am working on a small game project and I've been using Claude via antigravity for a while. I really like it, so I decided to buy claude PRO to give it a try.

Very nice...it's smart, it's fast, it gets my needs... but It barely lasted 4 small request before hitting my rate limit for the day. What am I doing wrong?

I also tried to break my code in small parts so It can read only what it needs but it seems like it didn't help much.

Posted here about a month ago about Koko Finance — a free tool to compare credit cards, check if your annual fee is worth it, and optimize your card portfolio.

Since then I've been building out the developer side:

• REST API — 15+ endpoints for card search, comparison, portfolio analysis, renewal checks. Free tier, 100 calls/month, no credit card needed.
• MCP server — connect it to Claude Desktop or Cursor in one line of config. AI agents get credit card intelligence without you building any of it.
• Python SDK — pip install koko-finance and you're calling endpoints in 3 lines.

The idea: if you're building a fintech app, personal finance tool, or AI agent that touches credit cards — you shouldn't have to maintain card data yourself.

Biggest lesson from the pivot: the consumer tool got usage, but developers asked "can I call this from my app?" enough times that I just built the API. Sometimes the product is the infrastructure, not the interface.

The consumer tools are still free at kokofinance.net — Card Studio, portfolio analysis, all of it.

If you want to poke at the API: kokofinance.net/developers.html

Happy to answer any questions about the build or the pivot from consumer to API-first.

This is an automatic post triggered within 2 minutes of an official Claude system status update.

Incident: Elevated errors on Claude Sonnet 4.6

Check on progress and whether or not the incident has been resolved yet here : https://status.claude.com/incidents/mfhmykgrbzt5

Also check the Performance Megathread to see what others are reporting : https://www.reddit.com/r/ClaudeAI/comments/1pygdbz/usage_limits_bugs_and_performance_discussion/

Nebu Luxury has some great scents but their diffusers don’t seem to have HA compatibility—you connect locally with your phone over Bluetooth. Does anyone know of any diffusers with HA compatibility, it’s currently the one automation gap among all my devices

Right now when you buy a toogoodtogo item, you can't see reviews online and have no clue what's in the bag.

I built this site as an aggregator for reviews for specific restaurants so you know what to expect when you make a purchase

surprisebagreviews.com

NYC-Only for now, but happy to add more cities/regions!

Any feedback on the site or help with spreading awareness would be appreciated!

Apologies for limited details here. Serious DMs ONLY from Technical Writers (NO AI WRITING, I can do that myself) if interested in helping to write a paper on the future of AI Agents.

• No compensation
• Co-author credit upon distribution
• Must help write paper with limited AI assistance

How are you all handling persistent context across Claude sessions?

I work across 4-5 active projects and find myself copy-pasting the same background context into every new conversation. Claude's project files help but they have limits.

Specific things I wish Claude automatically knew session-to-session:
- Code conventions and patterns
- Decisions we made and why
- My communication preferences

And for my openclaw I managed to get auto-SOUL updates but this sync in every interaction is burning a lot of tokens.

What approaches have you found that actually work?

Not sure if this question is for this sub but I'll shoot my shot. I asked about moving my Zigbee to Zigbee2MQTT away of ZHA, but to do that I learned I might have to upgrade my Conbee 2 firmware, is that really necessary or I just yeet it and go for it?

LiteParse is a lightweight CLI tool for local document parsing, born out of everything we learned building LlamaParse. The core idea is pretty simple: rather than trying to detect and reconstruct document structure, it preserves spatial layout as-is and passes that to your LLM. This works well in practice because LLMs are already trained on ASCII tables and indented text, so they understand the format naturally without you having to do extra wrangling.

A few things it can do:

• Parse text from PDFs, DOCX, XLSX, and images with layout preserved
• Built-in OCR, with support for PaddleOCR or EasyOCR via HTTP if you need something more robust
• Screenshot capability so agents can reason over pages visually for multimodal workflows

Everything runs locally, no API calls, no cloud dependency. The output is designed to plug straight into agents.

For more complex documents (scanned PDFs with messy layouts, dense tables, that kind of thing) LlamaParse is still going to give you better results. But for a lot of common use cases this gets you pretty far without the overhead.

Would love to hear what you build with it or any feedback on the approach.

📖 Announcement
🔗 GitHub

After 6 months of building with Opus 4.5, my friend and I just launched Serpdino🦖. It’s a low-cost Google rank tracking and competitor insights tool, packed with cool stuff for SEOs and none of that keyword limit nonsense.

Here are some features you get right out of the box:

• Unlimited keywords, projects, and domains
• 12K/mo SERP updates (enough to track 1,200 keywords every 3 days)
• AI Overview tracking
• Similarweb data integration
• Automated competitor detection & tracking
• 4 years of historical search volume data
• Keyword cannibalization detection
• Google Lighthouse monitoring

If you want to try https://serpdino.com/

Truth is, building stuff comes easy to me. Marketing? Not so much. A while back, I gave Google Pomelli a shot. The idea made sense right away - drop a link, receive ready-to-use messages that fit the brand. Spending time with it, though, problems popped up more than once

Stuck with just one option. Whatever Google decides is what you get. Tried switching between tools - Gemini here, GPT-4o there - but that doesn’t happen

Some folks go elsewhere, while I turn to Claude whenever clearer words are necessary. Choosing isn’t something Pomelli allows.

One brand at a time doesn’t work for me. Juggling several products meant constant mental resets - each shift felt like starting over. What helped? A system that treats every product like it speaks its own language. Now each one lives in its own space, built from the ground up just for how it behaves.

After making stuff online, sharing it everywhere by hand feels slow. What happens next matters just as much. The full path should include putting it live without extra steps.

Built it myself: DNA Studio, an AI tool for marketing that runs on your own servers. Works with any model you choose, no restrictions baked in. Set it up once, keep control forever.

How it works:

Start by dropping a web address into the box. Once you do that, Playwright gets to work scanning every page. It pulls out visual details like color schemes and typefaces used across the site. The way words are chosen on the pages helps figure out how the brand talks to people. Who they’re trying to reach becomes clearer through repeated themes and phrasing patterns. All of this builds a profile tied directly to their field of business

Start by choosing an AI service - maybe OpenAI, Anthropic, Gemini, or go local with Ollama if you want it free and offline. Once that’s set, shape your outreach plans so they fit how people use Instagram, then shift slightly for LinkedIn’s crowd. Think about Facebook next, adjusting tone like you would change lanes on a road. Over on X, keep things short but sharp, matching the pace there

Whatever works on one app often flops on another. A tight message fits neatly into a tweet but drowns in a blog comment. Hashtags spread like pollen on Instagram yet vanish without trace on LinkedIn. The voice that charms TikTok feels stiff on X. Some places reward brevity; others want depth. Matching form to function keeps things feeling natural. Tone shifts subtly depending on where it lands. Rules change per corner of the web

Each brand keeps its own stored data. That means answers show up fast every time past the start. First run prepares what comes next. Speed happens because nothing needs rebuilding. What you see stays ready once it appears

The Part I’m Most Excited About UGC Studio

Here things start to shift. Into the mix came a complete AI-driven video workflow, built for UGC-type output

- 12 AI creators (Sofia, Marcus, Luna, etc.) each with their own look and persona

A little clip follows each character, made by Veo - just move your cursor close to watch them come alive ahead of choosing.

Start by uploading your item. Pick someone who fits the vibe. Craft words yourself - AI can step in if needed. A recorded pitch from that person follows, showing off what you offer

Works with Google Veo HeyGen and D ID

Paying three hundred to five hundred dollars every time for user-generated content? That old way feels heavy now. Imagine swapping that cash drop for something close to free each time you need another clip. When your product is just starting out - still finding its voice - this shift hits different. Suddenly, trying new messages isn’t stressful. Test after test flows easier when cost stops being a wall.

AI Photoshoot

Pictures of items, kind of like that idea. Drop in one photo of your thing. Pick how it shows up - 29 styles, six types to browse

Picture a mix of everyday themes - style, meals, gadgets, living spaces, good looks. Instead of listing choices, just see four unique images form at once, each shaped by your touch. These moments stick around, waiting where you left off. Jump back whenever, like returning to an open page. Each visit picks up right where it paused.

Tech stack for the curious:

Next.js 16 with TypeScript and Tailwind CSS v4

Prisma with PostgreSQL

One change in settings lets you switch between different language model suppliers. This setup works no matter which provider you pick. Switching needs just a single environment variable update. The system stays flexible without locking into one source

Image generation tools include OpenAI DALL-E Google Gemini Stability AI Replicate Flux

Google Veo HeyGen D-ID video tools

Docker Compose enables single command deployments

- MIT licensed

What's NOT done yet (being honest):

Behind the scenes, posting to social platforms like Twitter, Meta, and LinkedIn uses OAuth steps already built into the system. Connection between these workflows and the main engine hasn’t happened just yet. Pieces sit separate, waiting for a bridge. Setup exists, though it sleeps unused. Functionality stands ready - just not turned on

- Analytics/performance tracking

- Calendar view for scheduling

- Team collaboration

Why I built this:

Building things comes naturally to me. Yet when it's time to share them, everything slows down. Words never sit right on the page. Headlines feel off. Messages sound stiff, too technical. Explaining value? That part trips me every single time. So instead of forcing what I’m bad at, I built something that handles it for me. A quiet helper for the work I avoid. Not magic - just code filling gaps.

Maybe you’re like me - building things alone, stuck between coding and convincing people to care. Writing words feels harder than writing functions. Talking about your work? Even worse. This could help if that sounds familiar.

GitHub: github.com/moesaif/dna-studio “feel free to star”

A single command - docker compose up -d - and it starts. Curious to hear thoughts, particularly if you’ve tried Pomelli or anything like it, and see what’s not there.

I know a lot of you are going to say I’m the one who’s fcked, that my friends are fcked, and that you’re fine. Honestly, I really hope you are. I don’t care who you are, but I really mean this and I need to say it out loud.

I started using Claude Code as a non-tech person this January because of the whole "AI-native" wave in the startup scene. I built an automated email reply bot and it actually worked. I was so happy. I thought I had a superpower. I felt confident.

But now, I feel the exact opposite. I am really f*cked.

If you have a job, just stay there. Stay until you get laid off or your company goes out of business. I’m serious.

Have you guys tried Claude Cowork? Claude Code can be a bit hard if you’re not a developer and don't know the whole GitHub world, but Cowork is literally a second brain. It just does everything you ask, and the results are beyond what you’d imagine. If you haven’t used it, just trust me. Download it. Start using it. It’s so different from the Claude chat because it actually controls your computer and your browser. And, the dispatch function lets you use it from your phone.

We’re not in the AGI era yet, and nobody knows when it’ll come. But we all know it will come someday. And I think "someday" might be just 2–3 months away. The way you work in an office has completely changed. You say you use email, powerpoint, google sheets, blah blah, and that you’re using AI for assistance. But I’m not talking about assistance. I’m saying give control to Claude Cowork. It does everything you wish you could do, perfectly, with basically no mistakes. If you suddenly have a few extra hours in your day because of AI, imagine what else you could be doing. You never really thought about that, right?

Look at how AI hit the software engineering industry last year. Now, nobody writes code by hand anymore. Should they all just become business people too? No... we are already f*cked. We just weren't feeling it yet because paperwork isn't as actionable as code. That’s why I say this is going to become an even bigger snowball.

We are so f*cked and I don’t know what to do, so I’m just writing about it on Reddit. That’s literally all I can do right now.

Try to convince me I’m wrong. I’m not here to fight. I’m just saying what I’m feeling. I guess I feel somewhat positive about riding the wave, but that positivity is really just hope. Hope that everything will be fine.

I want to share something that took me too long to figure out.

For months I kept hitting the same wall. Agent works in testing. Works in the demo. Ships to production. Two weeks later — same input, different output. No error. No log that helps. Just a wrong answer delivered confidently.

My first instinct every time was to fix the prompt. Add more instructions. Be more specific. Sometimes it helped for a few days. Then it broke differently.

I went through this cycle more times than I want to admit before I asked a different question.

Why does the LLM get to decide which tool to call, in what order, with what parameters? That is not intelligence — that is just unconstrained execution with no contract, no validation, and no recovery path.

The problem was never the model. The model was fine. The problem was that I handed the model full control over execution and called it an agent.

Here is what actually changed things:

Pull routing out of the LLM entirely. Tool selection by structured rules before the LLM is ever consulted. The model handles reasoning. It does not handle control flow.

Put contracts on tool calls. Typed, validated inputs before anything executes. No hallucinated arguments, no silent wrong executions.

Verify before returning. Every output gets checked structurally and logically before it leaves the agent. If something is wrong it surfaces as data — not as a confident wrong answer.

Trace everything. Not logs. A structured record of every routing decision, every tool call, every verification step. When something breaks you know exactly what path was taken and why. You can reproduce it. You can fix it without touching a prompt.

The debugging experience alone was worth the shift. I went from reading prompt text hoping to reverse-engineer what happened, to having a complete execution trace on every single run.

Curious how others have approached this. Is this a solved problem in your stack or are you still in the prompt-and-hope loop?

I saw a post that said they signed the contract with US military to mass surveil but only US citizens are excluded from this surveillance. Is this true?

This is a QUESTION not a blatant accusation btw.

I lived in Brazil for 3 years. São Paulo and Rio mainly.

In the first few months I learned what every local already knows: your phone on the street is a risk. It's not paranoia, it's just reality.

The thing is, your iPhone becomes the literal key to your entire financial life. Banking, brokerage, crypto, personal documents. Everything in a device you carry in your pocket on the subway.

My solution for a long time was to keep all my banking apps on a separate phone, at home. I'd go out with a clean iPhone, nothing sensitive on it. It worked, but it was a constant hassle. Need to make a payment? Go back home. Want to check your balance? Go back home. Forgot to transfer money before leaving? Your problem.

I tried other workarounds:

• Hiding apps inside folders
• Logging out of banking apps before going out
• Using Focus Mode to make some icons disappear

None of it was a real solution. Anyone with access to an unlocked phone could undo it in seconds.

So I decided to fix it properly.

What I built

inZono. An iOS app that lets you create "zones" where apps genuinely disappear from your device with a single tap.

Not a folder. Not Focus Mode. Apps are suppressed by the OS itself using Apple's Family Controls + ManagedSettings framework, the same stack behind Screen Time, but enforced at a deeper system level. Passcode can't deactivate it. Only Face ID can.

The logic is simple: the most common theft in Brazil is the "passcode grab", thieves force you to type your passcode (or shoulder-surf it), snatch the phone and run. They open the phone. The banking apps aren't there. They don't even know what they're looking for.

Tech stack for the curious:

• FamilyControls + ManagedSettings → real app suppression at the OS level
• DeviceActivity → automatic zone scheduling without needing the app open
• CoreLocation + geofencing → activates your zone automatically when you leave home
• LocalAuthentication → Face ID required to deactivate (passcode doesn't work)

Free version:

• Create a zone, pick your apps, toggle protection on and off manually

Premium ($3.99/month or $29.99/year):

• Automatic scheduling by time of day
• Location-based activation (leave home → apps disappear)
• Face ID required to deactivate
• Prevents protected apps from being deleted
• Unlimited zones

I built this because I needed it. If you've ever left the house knowing your entire financial life was sitting on a device in your pocket, you probably get it.

Available on the App Store: https://apps.apple.com/app/inzono-focus-app-blocker/id6759056521

Happy to answer any questions about the Family Controls implementation or the overall approach, it's a pretty underexplored framework.

Hey everyone,

I need to run AI image generation fully locally on CPU only machines. No GPU, minimum 8GB RAM, zero internet after setup.

Already tested stable-diffusion.cpp with DreamShaper 8 + LCM LoRA and got ~17 seconds per 256x256 on a Ryzen 3, 8GB RAM.

Looking for real world experience from people who actually ran this on CPU only hardware:

• What tool or runtime gave you the best speed on CPU?
• What model worked best on low RAM?
• Is FastSD CPU actually as fast as claimed on non-Intel CPUs like AMD?
• Any tools I might be missing?

Not looking for "just buy a GPU" answers. CPU only is a hard requirement.

Thanks

Hey everyone, I’ve been working on a side project for a while and finally pushed it live: OpenLoom, a free, open‑source Bloomberg‑style financial terminal that runs in your browser. 👉 Live app: https://openloom.in What it is OpenLoom is a Bloomberg‑style market dashboard aimed at traders, investors, and finance nerds who want an information‑dense view of the markets without paying terminal prices. It’s built to feel more like a professional terminal than a simple watchlist site. What you can do with it (current focus) Right now, OpenLoom is focused on giving you a single place to monitor and trade: Stocks Forex Crypto Commodities Bonds, futures, and options (coverage and depth still evolving) Paper trading – test strategies, track hypothetical PnL, and backtest ideas risk‑free Note on data: Currently running on free APIs/datasets, but I have plans to integrate premium data feeds (Polygon, Alpha Vantage, etc.) if the project gets support and traction. Why I built it Professional terminals are insanely powerful, but the cost puts them out of reach for most individuals and smaller teams. On the other hand, many “alternatives” either feel too basic or too clunky for day‑to‑day use. I wanted something you can simply open in a tab, get a terminal‑style experience with paper trading, and just use — for free. What I’d love feedback on I’d really appreciate feedback on: What would make this genuinely useful in your daily trading/investing workflow? How useful is the paper trading? What features would make it more powerful (multiple accounts, more instruments, export PnL, etc.)? Which data providers/APIs would you want to see next for more reliable/granular data? Which areas should I prioritize (screeners, options tools, alerts, news, portfolio views, macro dashboards, etc.)? Is the layout and information density comfortable, or does it feel overwhelming/too sparse? I’m actively iterating on this, so even small suggestions like “I wish I could see X next to Y” or “this screen needs Z data” are super helpful. If you give it a try, I’d love to hear what you think—good or bad. And if something breaks or feels off, tell me what you were trying to do so I can fix it.

One thing I’ve noticed is how revision costs quietly pile up. Sometimes people claim changes were made but nothing actually changes.

Rollback → redo → repeat → more money.

This cycle keeps going.

That’s where tools like Traycer, Claude Code’s Plan Mode really helps. Instead of blindly iterating, you first define exactly what needs to be built or changed. So before a single line is modified, you're aligned on:

• What will change
• What won’t change
• Expected outcome

Fewer surprises. Fewer fake revisions. Way less wasted money.

Honestly, this is the kind of control I wish every workflow had
What about you guys?

Every time I get deep into a long conversation research, writing, problem solving, coding I hit the same wall.

The chat gets long. Quality starts dropping. ChatGPT starts missing context from things I said 40+ messages ago. Responses feel less sharp.

So I opened a new chat. Instantly feels better. But now I've lost everything the background I spent 20 minutes giving it, the decisions we worked through, the specific framing that was finally working.

I've tried the "ask it to summarise everything and paste into a new chat" approach. Works sometimes. Fails other times. And takes 10 - 15 minutes when I just want to keep going.

A few genuine questions for people who use ChatGPT heavily for ongoing work:

1. Do you hit this wall too, or is it just how I'm using it?
2. What's your actual workaround when a specific conversation gets too long?
3. Has anyone found a way to carry context into a fresh chat that actually preserves the nuance, not just the bullet points?

Not looking for "use memory" or "use Projects" I know those exist. I mean mid session, when you're already deep in a specific chat and it's degrading. What do you do then?

This is an automatic post triggered within 2 minutes of an official Claude system status update.

Incident: Elevated errors on Claude Sonnet 4.6

Check on progress and whether or not the incident has been resolved yet here : https://status.claude.com/incidents/mfhmykgrbzt5

Also check the Performance Megathread to see what others are reporting : https://www.reddit.com/r/ClaudeAI/comments/1pygdbz/usage_limits_bugs_and_performance_discussion/

how is it?

https://preview.redd.it/6cw4ylfqu0qg1.png?width=1920&format=png&auto=webp&s=6e367f2a49ae47fa080cb267ab04e81fe1001eef

https://preview.redd.it/7hqlmlfqu0qg1.png?width=1920&format=png&auto=webp&s=b5a5b8e7e5a896828d9503859226a25827e64f83

https://preview.redd.it/vg2t9lfuu0qg1.png?width=1024&format=png&auto=webp&s=56de3478c3f574fe04fc59324382ae603afc136e

https://preview.redd.it/nu6cqkfuu0qg1.png?width=1024&format=png&auto=webp&s=9fe6ef964abc12eb5d6d8f66031c03adba5a94ad

Hi everyone,

I’m currently working on my own original neo-noir visual novel and experimenting with training character LoRAs.

For my main models, I used datasets with ~450+ generated images per character. All characters are fictional and trained entirely on AI-generated data.

In the first image — a result from the trained model.

In the second — an example from the dataset.

Right now I’m trying to achieve similar quality using much smaller datasets (~40+ images), but I’m running into consistency issues.

Has anyone here managed to get stable, high-quality results with smaller datasets?

Would really appreciate any advice or tips.

"ChatGPT isn't designed to provide this type of content.

Read the Model Spec for more on how ChatGPT handles creators' content."

I'm getting it for EVERY prompt today. Is it just down? Did I get shadow banned? We're talking completely inoffensive help me come up with a script for a video about my business kinda thing...

If someone is getting into vibe coding now as a semi technical person (think product manager in tech) how many claude skills are you normally running? Is it worth it to start with skills from the beginning or stick with base claude code/claude cursor?

I see folks talking about super human, test driven development, etc. And other claude skills/extensions. I have been using base claude since it came out but haven't really played around with the skills much.

Current use case is trying to vibe code my own app.

Just launched my side project 🚀

A salon & spa management system with:
• Online booking
• POS & billing
• Staff tracking
• WhatsApp automation
• Reports

Main twist: no monthly fees — one-time purchase

Would really appreciate feedback 🙌
[https://mrabhishek.com/salonxpa/]()

Hey folks, Been tinkering with fine-tuning Qwen3-8B to make models that respond like contemplative teachers—without any system prompt, persona, or RAG. Just ask something like "Why am I suffering?" and it points back in the style of the teachings (Krishnamurti inquiry, Nisargadatta negation, Osho provocation, etc.). No therapy fluff, keeps the radical edges. Main one is Meditation-Agent-8B-GGUF (blends 9 teachers: Krishnamurti, Nisargadatta, Osho, Thich Nhat Hanh, Tolle, Watts, Spira, Atmananda, Pema Chödrön). Runs smooth on ~8GB VRAM, Q8_0 GGUF for LM Studio / Ollama / llama.cpp. → https://huggingface.co/Sathman/Meditation-Agent-8B-GGUF

For purer single voices I did: TNH-Agent-GGUF (pure Thich Nhat Hanh – warm, breath, interbeing) → https://huggingface.co/Sathman/TNH-Agent-GGUF Osho-Agent-GGUF (pure Osho – explosive, tantra, celebration) → https://huggingface.co/Sathman/Osho-Agent-GGUF

Quick no-prompt examples: User: Why am I suffering? Model (TNH style): Suffering is not your enemy. It is a messenger. When you breathe in and touch your suffering with mindfulness, it begins to reveal its roots... User: Can you give me a step-by-step guide to enlightenment? Model (Osho style): Ah, you want steps! Steps to where? You are already there—you just don't know it. The seeker is the sought... Stop seeking for one moment and see what remains.

Trained with a thing I call A-LoRA on "atoms" from their books. Full details (training setup, eval, teacher list, disclaimers—not therapy or guru replacement) are in the READMEs linked above. If you load any in Ollama or LM Studio, lemme know: does the voice feel legit? Any spots where it falls flat? Thinking about a 4B version for lower VRAM too. Thanks for any eyes or tests—appreciate it. (Sathman on HF)

Good day gentlefriends,

I am a Psychology Undergraduate Student at Florida Atlantic University (or FAU) named Kaeley. I am doing a study on Artificial Intelligence/LLM usage (such as ChatGPT, Replika, Character.ai, etc) and the correlations and interactions between said usage and personality/culture. If you are under the age of 18, you cannot participate, but ANYONE (regardless of country, so non-Americans can participate) over the age of 18 is encouraged to post. The survey should take about 10-15 minutes, and if you feel uncomfortable at any point, you can exit out of the survey with no repercussions. The survey is also anonymous, and there will be no identifying information recorded (such as name or address). All data will be held on private machines and servers.

The study is referring to Generative Artificial Intelligence tools, such as ChatGPT, Replika, Character.ai, Google’s Bard, Google’s Gemini, Anthropic Claude, or Perplexity. We are not referring to generative AI tools such as Midjourney or Dall-E since they are not chatbots, we are referring to chatbot specific programs. (However, If you use Chatbots, such as ChatGPT, to generate art, you are included in the wanted demographics.) This survey is also not referring to artificial intelligence tools such as Grammarly or Prowritingaid (as they are editing tools, and while they incorporate generative ai, it is not a chatbot and the primary function of the design), and it is not referring to algorithms such as the ones presented in video games or on social media platforms.

As mentioned, the survey is looking at demographics, personality, etc, to determine what kinds of people use generative artificial intelligence / LLM’s, and susceptibility to using them.

The survey link is here: https://fau.az1.qualtrics.com/jfe/form/SV_barGZQjsj0C08Cy

Once you finish filling it out, it would be a huge favor if you were to send this to friends/family/other people you know to have them fill it out too would be great. It’ll be extremely helpful.

I’ve been thinking about this lately.

We can feel something real from a story, even when we know it’s fiction.

I once met someone who refused to read anything but non-fiction. He wouldn’t watch movies unless they were based on real events.

It made me wonder whether meaning always depends on who is speaking, or whether sometimes the feeling itself is enough.

Curious what others think.

Since Congaduto is a Valetudo variant, you can now easily extract maps from these vacuums using MQTT Vacuum Camera 😉

It also supports rendering detected floor materials, and all three Valetudo flavours are now covered.

Congaduto support is pretty new, so more improvements are coming soon!

https://preview.redd.it/t4umbfc141qg1.png?width=419&format=png&auto=webp&s=4274257a72f3fb6aa767f65940f1f39e49c8aa99

Do i need to upgrade to get the 1m tokens context window?

noticed a weird gap when building voice agents.

every other layer of the stack gets monitoring as a given. apis have uptime checks. databases have performance alerts. llm calls have latency tracking.

voice agents get almost nothing by default.

the result is that you are basically waiting for a customer to complain before you know something went wrong. no proactive alerts, no health signals, no way to spot a degrading pattern across calls before it becomes a real problem.

the things that actually matter for voice agent health are not obvious errors:

• the agent struggling on a specific type of input consistently
• context dropping mid-call without a hard failure
• response quality quietly degrading across a subset of calls
• latency creeping up in ways that hurt the experience but do not trigger alerts

for text-based agents and apis, this kind of monitoring is table stakes. for voice, most teams are still doing reactive review of recordings after something breaks.

curious if people here have actually solved this or if everyone is still kind of winging it in production.

Hey r/SideProjects! I have been solo building a free workout app called MyRepsCount over the last year and wanted to share my progress with you all.

What it does: The app uses the phone's camera and google mediapipe posedetection to count reps for 16 exercises in real time. It also acts as a workout player, advancing through the workout as your complete the movements. It supports standard, tabata, and AMRAP and will log all set and rep information.

One recent feature I have been working on is called Focus. It leverages the Screentime and FamilyControls capabilities to block app access. Users select what apps they want blocked and only after you workout will you be able to scroll. Users do have control over which days are blocked, which apps are blocked, what workout criteria is needed to unblock, how long the unblock lasts (rest of day or down to only 15 minutes), and when the block activates (midnight, 9am, 5pm). This has helped me avoid rolling out of bed and hopping on tiktok.

The app is free with one ad that pops up after workout completion. Would love your feedback. I am closing in on 1k downloads but only have earned ~$20 in 3 months.

iOS: https://apps.apple.com/us/app/myrepscount-workout-tracker/id6748878622

Android: https://play.google.com/store/apps/details?id=com.myrepscount&hl=en_US

Researchers at UCLA's Institute of the Environment and Sustainability have developed the most high-resolution statewide maps of California's kelp forests to date, giving researchers, conservationists and community members unprecedented access to information essential to maintaining coastal ecosystems and the communities they support.

By applying AI deep learning to Planet's Dove satellite constellation, the team has created a map 10 times more detailed than previous standard satellite records, offering a more precise way to monitor the condition of kelp along the California coastline and the success of conservation efforts.

"Refined spatial resolution of kelp canopy monitoring has become increasingly important for assessing the efficacy of experimental restoration techniques and managing kelp harvest, particularly in areas where persisting kelp is sparse," said Dr. Kristen Elsmore, senior scientist with California Department of Fish and Wildlife, the state's primary agency responsible for managing California's kelp forest resources.

Recent declines in kelp abundance have threatened the foundation of California's coastal ecosystems and economy.

California's kelp forests support thriving fisheries, protect marine biodiversity and attract significant revenue through recreational snorkeling and scuba diving. They also play a crucial role in sustainability by contributing to nutrient cycling and carbon sequestration.

This project represents a massive leap in conservation technology. While existing methods provide valuable long-term records, their 30-meter resolution can miss fine-scale patterns.

When analyzing data from the new high-resolution map, the researchers found striking regional variability in kelp persistence following the 2014–2016 marine heat wave, one of the most severe warming events ever recorded along the U.S. West Coast. Kelp forests in Sonoma and Mendocino counties suffered losses of greater than 90% and remain at historically low levels ...

"These high-resolution data can also be used to track small-scale restoration, helping guide management and support kelp forest resilience," lead author Kate Cavanaugh said.

By identifying exactly where kelp is struggling or thriving based on local factors like ocean temperature and depth, conservationists can now implement an expanded suite of strategies within the state's Kelp Restoration and Management Plan.

I’ve been working on a side project called Tymz. I know there are a lot of scheduling tools out there, but most are built for 1:1 meetings or basic booking links.

I wanted something that had clean, customizable templates that feel polished, especially for things like events, clubs, or volunteer groups and I kept running into tools like Doodle that felt cluttered and full of ads or ugly like when2meet.

Would love any feedback, especially if you’ve dealt with coordinating groups before.

App Store Link:

https://apps.apple.com/us/app/tymz-scheduling/id6756507993

Play Store Link:

https://play.google.com/store/apps/details?id=com.tymz.app

Web Site:

https://tymz.ai

Sometimes I just don’t know what to do while waiting for completion. And if I start to do other tasks, I feel like Im losing focus. So Im reading everything claude throws while executing

Heart disease is the leading cause of adult death worldwide, making cardiovascular disease diagnosis and management a global health priority. An echocardiogram, or cardiac ultrasound, is one of the most commonly used imaging tools employed by physicians to diagnose a variety of heart diseases and conditions.

Most standard echocardiograms provide two-dimensional visual images (2D) of the three-dimensional (3D) cardiac anatomy. These echocardiograms often capture hundreds of 2D slices or views of a beating heart that can enable physicians to make clinical assessments about the function and structure of the heart.

To improve diagnostic accuracy of cardiac conditions, researchers from UC San Francisco set out to determine whether deep neural networks (DNNs), a type of AI algorithm, could be re-designed to better capture complex 3D anatomy and physiology from multiple imaging views simultaneously. They developed a new "multiview" DNN structure—or architecture—to enable it to draw information from multiple imaging views at once, rather than the current approach of using only a single view. They then trained demonstration DNNs using this architecture to detect disease states for three cardiovascular conditions: left and right ventricular abnormalities, diastolic dysfunction, and valvular regurgitation.

In a study published March 17 in Nature Cardiovascular Research, the researchers compared the performance of DNNs that analyzed data from either single view or multiple views of the echocardiograms from UCSF and the Montreal Heart Institute. They found that DNNs trained on multiple views improved diagnostic accuracy compared to DNNs trained on any single view, demonstrating that AI models combining information from multiple imaging views simultaneously better captured the disease state of these heart conditions.

"Until now, AI has primarily been used to analyze one 2D view at a time—from either images or videos—which limits an AI algorithm's ability to learn disease-relevant information between views," said senior study author Geoffrey Tison, MD, MPH, a cardiologist and co-director of the UCSF Center for Biosignal Research.

"DNN architectures that can integrate information across multiple high-resolution views represent a significant step toward maximizing AI performance in medical imaging. In the case of echocardiography, most diagnoses necessitate considering information from more than one view because the information from any single view tells only part of the story."

​Liquid AI and DPhi Space are inviting builders, researchers, and space enthusiasts to join a global online hackathon exploring what happens when AI meets satellite intelligence.

​What if satellites came equipped with onboard compute, allowing AI models to run directly in orbit instead of back on the ground? This is what this hackathon is all about. AI in space.

​Over the course of the hackathon, participants will build creative applications using satellite imagery, vision models, and space data to solve real-world challenges and unlock new possibilities for Earth observation.

​Whether you're interested in space tech, AI models, computer vision, or experimental builds, this is an opportunity to collaborate with developers around the world and push the boundaries of what AI can do beyond the cloud.

​The hackathon is fully online and open to participants around the world.

​
Tracks

​The hackathon runs across two tracks.

1. ​The Liquid Track is for projects built with Liquid AI's LFM2-VL and LFM2.5-VL vision-language models, where fine-tuning on domain-specific satellite data is strongly encouraged.
2. ​The General AI Track is open to any AI approach, with preference for solutions designed around the realities of space-based compute: limited downlink, continuous data streams, and on-board inference.

​
Judging

​All submissions are judged on four criteria:

1. ​Use of satellite imagery from the DPhi API
2. ​Innovation and problem-solution fit
3. ​Technical implementation (your app must run without debugging), and
4. ​Demo where you walk through your solution end-to-end.

​
Prizes

• ​Liquid Track winner: Credits for software execution in space worth around $15,000 + $5,000 cash
• ​General Track winner: Credits for software execution in space worth around $15,000

​For the full breakdown of judging criteria, weights, and detailed descriptions for each track prizes, see the Judging Criteria and Prizes document.

​
Join the Community

​All hackathon discussion, Q&A, and updates will happen in the Liquid AI Discord Server. Whether you're

• ​looking for teammates
• ​have technical questions about LFM2-VL, or
• ​want to share what you're building

​this is where it all comes together.

​Join today and head to the hackathon channel #ai-in-space-hackathon

​See you in orbit!

Codex CLI saves conversations locally and doesn't sync with the web interface. Claude Code syncs your sessions to a dashboard so you can review them later or share them, but Codex CLI has nothing equivalent.

I built codex-share to fill that gap. It reads your local Codex CLI conversation files and serves a web UI where you can browse sessions, view full conversation history with code blocks and tool calls rendered properly, and share the convos.

It is open source and free: https://github.com/manitofigh/codex-share

I’ve recently been working on an OpenClaw alternative which can run with models from 0.8b+. Like many, I didn’t want to pay for hardware for 20b+ models so I put together this framework which gives small micro agents autonomy and tools to complete tasks. I'm hoping this finds the right crowd and helps you all run local micro agents easier

Hey everyone,

I built a small iOS app called Meeple Score.

It started from a simple frustration: scoring board games at the end of a game is often slow, messy, and easy to mess up (especially for more complex games).

So I made something to fix that:

• built-in scoring for specific games
• support for expansions
• automatic calculations
• and a universal mode for any game

The goal was just to make game nights smoother and less annoying.

Would love to hear what you think — especially if you play board games.

Here’s the link:
https://apps.apple.com/fr/app/meeple-score-compteur-jeux/id6759367936

Thanks!

Hey everyone, I’m planning to subscribe to Claude Code to build an app using SwiftUI.

Context:

• Coming from React Native
• About 1 week learning SwiftUI
• Always used tools like Cursor/Antigravity

I want to get the most out of this stack (SwiftUI + Claude).

For those already working with it:
What are the essentials to learn early on to avoid wasting time?

(architecture, patterns, how to use Claude effectively, common mistakes, etc.)

the standard approach for most teams is to manually chat or call their own agent a few times, check if it sounds okay, and ship it.

that works until real users show up with:

• weird phrasing the agent was not trained for
• interruptions mid-sentence
• off-script turns that break the conversation flow
• edge cases that only surface at volume

by the time you catch those in production, it is already a user experience problem.

the pattern that actually helps is running structured simulations before production. define a set of personas, realistic scenarios, and edge cases, then let the simulation run hundreds of conversations you would never manually test.

what good simulation catches that manual testing misses:

• the agent hallucinates mid-conversation and never recovers
• context drops after a few turns
• the agent handles the scripted path fine but breaks on any variation
• adversarial inputs that cause the agent to go off-rails

the output that matters is not just pass/fail but why it failed and where in the conversation things went sideways.

curious how others here are approaching pre-production testing for agents. are you doing manual QA, scripted test cases, or something more systematic?

I’ve been seeing a lot of really solid projects getting built lately, which is great.

But I’m curious what are people actually doing for security?

Are you mostly relying on out-of-the-box AI agent recommendations and whatever security comes with third-party tools? Or are you intentionally designing and implementing your own security controls?

Feels like a lot of people are moving fast (which makes sense), but I don’t see much conversation around how security is being handled.

Would be interesting to hear how others are approaching this.

Anyone else notice this lately?

If you use overnight setback (lower temp at night), you’ve probably run into this:

• Start heating too early → waste energy
  
• Start too late → cold mornings
  

I got tired of guessing schedules, so I built something in Home Assistant that learns how long my house actually takes to heat up and starts preheating automatically.

What it does

• Learns heating rate from real cycles
  
• Figures out when to start heating
  
• Aims to hit your comfort temp right at your target time
  

It runs entirely in HA (Pyscript) and works with any thermostat (climate entity).

What made the biggest difference

Most thermostat “smart recovery” features keep learning even after the target temp is reached.

That turns out to be a problem on modulating systems.

This instead: 👉 Stops learning at the first time the target is hit

That ended up making the timing much more stable.

Reality check

It’s not perfectly exact every day (weather, house dynamics, etc.)

But over time it: - Gets consistently close
- Prefers being slightly early vs late
- Doesn’t oscillate like a lot of smart thermostat features

Example

• Night setback: 65°F
  
• Target: 70°F at 7:00 AM
  

It figures out when to start heating so you wake up at 70.

If you want to check it out

Full repo + docs: https://github.com/dbullendsl/hvac-comfort-start

Curious if others have tried solving this differently, or run into the same problem.

Most setups we’ve seen fall into two buckets:

• multi-minute cold starts (model load + init)

• or paying to keep GPUs warm to avoid that

We’ve been experimenting with a different approach:

restoring initialized state instead of reloading weights.

This lets us switch models in sub-second time, even for ~32B models, without keeping GPUs idle.

If anyone wants to try their own models, happy to spin things up and share results.

We’re also working on a simple desktop version for local use and planning to release it for free.

I asked it to summarize this nytimes article ( https://www.nytimes.com/2026/03/16/opinion/financial-crisis-private-credit-ai-iran-taiwan.html?unlocked\_article\_code=1.UFA.3HjB.BS3TIxZ3qJ9g&smid=em-share ) which it did. Then I asked it who wrote the piece. It said Nouriel Roubini and proceeded to tell me that this is what explains the tone of the article. It was NOT written by Roubini, it was written by Bookstaber.

As it says on the tin, ChatGPT makes mistakes.

Something I’ve been running into across different models (not just ChatGPT).

You can set up a fairly strict prompt — role, constraints, output format — and it works well at the start.

But over longer contexts, the behavior drifts:

– constraints weaken

– responses become more verbose

– structure loosens

– the model starts adding things you didn’t ask for

Even when the original instructions are still technically in the context window.

A common explanation is “bad prompting”, but that doesn’t fully match what’s happening. You can make the prompt longer, stricter, repeat constraints — it helps, but only temporarily.

It feels more like a signal-to-noise issue inside the context.

As more tokens accumulate, earlier instructions don’t disappear, but their relative influence drops. The model’s behavior becomes more dependent on recent tokens than on the initial constraints.

That would explain why:

– longer prompts don’t really fix drift

– “reminder” prompts only delay it

– restarting the conversation restores behavior

In that sense, prompts behave more like an initial bias than a persistent control mechanism.

Which raises a question:

Are we overloading prompt engineering with something it’s not designed to do — maintaining stable behavior over long contexts?

And if behavior is effectively a function of the current attention distribution, does it make more sense to think in terms of controlling conversation state rather than just stacking instructions?

Curious how people here think about this, especially those working with local models / longer context setups.

I've been running open-source models in production for a while now and finally sat down to do a proper comparison against Claude Opus 4.6, which is basically the default "serious production" model right now (Anthropic has ~54% of enterprise coding market share). The results surprised me. Here's what I found across every major category. ### General Reasoning: DeepSeek V3.2 DeepSeek V3.2 holds its own against the top proprietary models. Its high-compute variant (V3.2-Speciale) actually surpasses GPT-5. **SWE-bench Verified (% resolved):** | Model | Score | |---|---:| | Claude Opus 4.6 | 80.8% | | DeepSeek V3.2 | 73.0% | **LiveCodeBench:** | Model | Score | |---|---:| | Claude Opus 4.6 | 76 | | DeepSeek V3.2 | 74.1 | **MMLU-Pro:** | Model | Score | |---|---:| | DeepSeek V3.2 | **85.0%** | | Claude Opus 4.6 | 82.0% | DeepSeek V3.2 wins MMLU-Pro. Strong multilingual support (CJK, Arabic, European languages). 128K context with sparse attention. Falls short on creative writing and some structured output edge cases. Inference: ~60 tok/s output, 1.18s TTFT, 128K context. **Bottom line:** Production-ready for 90%+ of general use cases. 5x cheaper than GPT-5, 20x cheaper than Opus 4.6. --- ### Reasoning: DeepSeek R1 This is where it gets interesting. R1 beats the most expensive reasoning models on several benchmarks. **Humanity's Last Exam (%):** | Model | Score | |---|---:| | DeepSeek R1 | **50.2%** | | Claude Opus 4.6 | 40.0% | **MMLU-Pro:** | Model | Score | |---|---:| | DeepSeek R1 | **88.9%** | | Claude Opus 4.6 | 82.0% | Inference: ~30 tok/s output, ~2s TTFT. Slower than non-reasoning models, which is expected since it's doing chain-of-thought. The CoT is verbose, but you're trading speed for depth. **Bottom line:** Best open-source reasoning model. Matches GPT-5.2 Pro on HLE. 30x cheaper than o1. --- ### Agentic: Kimi K2.5 1 trillion parameters (32B active per token via MoE). 256K context. Open-source under modified MIT. This model changed the conversation about open-source agents. **Tool use improvement (points gained with tool access):** | Model | Gain | |---|---:| | Kimi K2.5 | **+20.1 pts** | | Claude Opus 4.6 | +12.4 pts | | GPT-5.2 | +11.0 pts | Read that again. Kimi gains 20 points when given tools, vs 12.4 for Opus and 11 for GPT-5.2. It can autonomously spawn up to 100 sub-agents in parallel and handle 1,500+ tool calls without human intervention. **SWE-bench Verified:** | Model | Score | |---|---:| | Claude Opus 4.6 | 80.8% | | Kimi K2.5 | 76.8% | **Humanity's Last Exam:** | Model | Score | |---|---:| | Kimi K2.5 | **50.2%** | | Claude Opus 4.6 | 40.0% | Inference: 334 tok/s output, 0.31s TTFT. Yes, 334 tokens per second. Fastest large model I've tested. **Bottom line:** Best model for autonomous agent workloads. Fastest TTFT, best tool use, competitive on every benchmark. --- ### Code: MiniMax M2.5 MiniMax M2.5 quietly became one of the best coding models, open-source or proprietary. **SWE-bench Verified (% resolved):** | Model | Score | |---|---:| | Claude Opus 4.6 | 80.8% | | MiniMax M2.5 | 80.2% | | GLM-5 | 77.8% | That's a 0.6 point gap. Basically a rounding error. MiniMax also just released M2.7 (March 18) -- a "self-evolving" model at $0.30/$1.20 per M tokens. 96th percentile on coding accuracy, perfect score on general knowledge. One of the cheapest frontier models available. **Bottom line:** Open-source coding models effectively match the best proprietary model. --- ### Speed Comparison For production, latency matters as much as quality. Here are output speeds and TTFT: **Output speed (tokens/second):** | Model | tok/s | |---|---:| | Kimi K2.5 Turbo | 334 | | Llama 3.1 8B | ~200 | | GLM 4.7 Flash | ~150 | | DeepSeek V3.2 | ~60 | | Claude Opus 4.6 | 46 | | DeepSeek R1 | ~30 | **Time to first token (TTFT):** | Model | TTFT | |---|---:| | Llama 3.1 8B | 0.2s | | Kimi K2.5 Turbo | 0.31s | | GLM 4.7 Flash | 0.51s | | DeepSeek V3.2 | 1.18s | Kimi K2.5 at 334 tok/s is 7x faster than Opus at 46 tok/s. Even DeepSeek V3.2, which is the "slow" one here, still pushes 60 tok/s. --- ### Vision Open-source vision has caught up for document processing and standard image analysis. Llama 4 Scout, Qwen VL, and others handle document extraction (invoices, receipts, forms), diagram understanding, and multi-image reasoning well. Still falls short on fine-grained spatial reasoning and non-Latin handwriting. --- ### The Full Picture Here's how the best open-source model in each category compares to Claude Opus 4.6, across five dimensions. Think of it as a radar chart where Opus 4.6 = 100% on each axis: - **Code (SWE-bench):** Open-source 80.2% vs Opus 80.8% -- Opus wins by 0.6 pts. Basically tied. - **Knowledge (MMLU-Pro):** Open-source 88.9% vs Opus 82.0% -- Open-source wins by 6.9 pts. - **Speed (tok/s):** Open-source 334 vs Opus 46 -- Open-source is 7.3x faster. - **Tool Use (improvement):** Open-source +20.1 pts vs Opus +12.4 pts -- Open-source wins by 62%. - **Reasoning (HLE):** Open-source 50.2% vs Opus 40.0% -- Open-source wins by 10.2 pts. Open-source matches or exceeds Opus 4.6 on 4 out of 5 dimensions. The only area where Opus still leads is code quality on SWE-bench, by 0.6 percentage points. ### Summary Table | Use Case | Open-Source Model | Benchmark | Speed | Best Proprietary | Its Score | Price Gap | |---|---|---:|---:|---|---:|---:| | General | DeepSeek V3.2 | 73.0% SWE | 60 t/s | Claude Opus 4.6 | 80.8% | 20x cheaper | | Reasoning | DeepSeek R1 | 50.2% HLE | 30 t/s | Claude Opus 4.6 | 40.0% | 10x cheaper | | Agentic | Kimi K2.5 | +20.1 tool use | 334 t/s | Claude Opus 4.6 | +12.4 | 10x cheaper | | Code | MiniMax M2.5 | 80.2% SWE | ~50 t/s | Claude Opus 4.6 | 80.8% | 17x cheaper | | Vision | Llama 4 Scout | 14 models | ~80 t/s | Claude Opus 4.6 | -- | 62x cheaper | | Fast | Llama 3.1 8B | 0.2s TTFT | 200 t/s | Claude Opus 4.6 | 46 t/s | 250x cheaper | *Benchmarks: SWE-bench Verified, Humanity's Last Exam (HLE), Artificial Analysis tool use improvement. Prices from official APIs, March 2026.* ### What "production-ready" actually means 1. **Reliable enough.** Consistent quality across thousands of requests. 2. **Fast enough.** Sub-second TTFT. 334 tok/s on Kimi K2.5. 3. **Capable enough.** MiniMax M2.5 matches Opus 4.6 on SWE-bench. DeepSeek R1 matches GPT-5.2 Pro on HLE. 4. **Predictable.** Versioned models that don't change without warning. That last point is underrated. Proprietary models change under you. Fine one day, different behavior the next. No changelog, no warning. Open-source models are versioned -- DeepSeek V3.2 behaves the same tomorrow as today. You choose when to upgrade. For production workloads, that predictability is worth more than a marginal quality edge on any single benchmark. **Sources:** [Artificial Analysis Leaderboard]( https://artificialanalysis.ai/leaderboards/models ) | [SWE-bench Leaderboard]( https://www.swebench.com/ ) | [Kimi K2.5 Benchmarks]( https://kimi-k25.com/blog/kimi-k2-5-benchmark ) | [MiniMax M2.7]( https://artificialanalysis.ai/models/minimax-m2-7 ) | [DeepSeek V3.2]( https://artificialanalysis.ai/models/deepseek-v3-2 ) | [OpenAI Pricing]( https://openai.com/api/pricing/ ) | [Anthropic Pricing]( https://platform.claude.com/docs/en/about-claude/pricing ) 

About 6 months ago, I got fed up trying to build schedules for my adult sports league. I’d spend hours using manual matrices just to mess up one thing and break the entire schedule. So, I decided to learn how to build an app to solve my own problem and made BrackIt.

I'm writing this because when I started, I had no idea what I was doing. Reading other people's vibe-coding journeys on Reddit really helped me. The short story: if you're on the fence about building an app, just do it.

**How I started**

I messed around with AI builders like Lovable but settled on FlutterFlow because I wanted full customization. I actually wanted to learn the "hows and whys" of app logic. I started in Figma, then used Claude to guide me through building it in FlutterFlow with a Firebase backend. Claude walked me through building everything from scratch like containers, app states, custom components. It took way longer than using templates, but I don't regret it because I actually learned how data flows. Security of AI code is still a huge fear of mine, so I’ve done my best to add safeguards along the way.

**My biggest struggle**

Testing the scheduling algorithm. As I added more parameters, I had to constantly remake tournaments just to test the results. Sometimes I'd build for an hour, realize something broke, and have to roll back to an earlier snapshot because I didn't know what happened. Rescheduling logic was also a nightmare. If a week gets rained out, shifting the match lists, component times, and match orders took a lot of "I tried this and nothing is updating" prompts with Claude until I finally got it right.

**Marketing**

I didn't "build in public." Honestly, I was scared of failing and didn't want the pressure of hyping something up while balancing my day job and running a league. Knowing what I know now, I probably would next time, but for this app, I just wanted to solve my own pain point.

**Where I'm at now**

I’m finally at a place where I'm proud of the app. I'm currently beta testing it with other organizers and fixing minor bugs. I haven't submitted to the App Stores yet, but I'm hoping to be confident enough to launch in late March or early April.

**The Stack:**

Website: Framer ($120/yr)

Dev: FlutterFlow ($39/mo)

Backend: Firebase (Free)

In-App Purchases: RevenueCat

AI: Claude ($20/mo)

tl;dr: PearlOS is self-evolving intelligent companion OS that learns and grows quickly over time. She takes notes, creates new apps for you, and gains new abilities. She can even create new UI. This is a free, open source, local OS that leverages a swarm of different intelligences and a OpenClaw bridge. Just went live with our first early access release on GitHub.

Check the progress of your swarm on a task list that lets you give feedback. Works on mobile, desktop, tablets all inside a simple browser interface.

Pearl can access image generation capabilities locally to create anything out of pixels. This lets her build and create pixel experiences, games, or icons on the fly. The idea is an intelligence that can speak, listen, learn, and create any kind of pixel interface at the user's request. We have a vision system in the early access build but it hasn't really been fully connected. Feel free to contribute that to our GitHub.

https://preview.redd.it/ellbv6vbk0qg1.png?width=1078&format=png&auto=webp&s=cadf88801e70cd5470153fd2d39e7b40508bccd6

This community, LocalLLaMA, has been a huge help to me and my entire engineering team while we were building PearlOS over the last year. I mostly lurk but this is one of the best place for on the ground reports of what models are working. I thought it would be cool to show you some details under the hood of our new open source OS designed from the ground up for intelligence. The OS is fully integrated with OpenClaw and OpenRouter allowing a lot of ways to play with how your Pearl companion thinks and reacts.

PearlOS connects to models through OpenRouter, so you can point it at whatever you're running. Llama, Mistral, Qwen, local Ollama instance, cloud API, whatever. The system routes between a fast model (chat, intent classification) and a heavier model (code gen, complex reasoning) depending on the task. You pick which models fill which role.

We're currently running Haiku and Gemini mostly for fast voice and tool responses and Opus/Codex/GLM for heavy coding (she evolves herself), but the whole point is that these are swappable. If you've got a local 70B running on your rig, Pearl can use it.

A huge part of what we wanted to do was to take intelligent agents beyond the text command line. Pearl's voice output uses PocketTTS running locally. No cloud TTS dependency for core function. Quality is decent, latency is good. We also support ElevenLabs if you want higher quality voices for OS agents, but it's optional.

The voice pipeline is built on Pipecat (Deepgram STT → your model → PocketTTS). Handles interruption, turn taking, and streaming. Pearl can be interrupted mid sentence and respond naturally.

Early access release GitHub: https://github.com/NiaExperience/PearlOS/ Feel free to spin up a version. Would love to hear feedback and questions and if you're interested in becoming a contributor, all you have to do is run the OS. She edits her own code and can push to GitHub. Hope you find her as fascinating and useful as we do.

Words, AI, and games all operate under the same principle: the outcomes we produce reflect the depth of our daily engagement and practice. Just as a gamer’s habits, choices, and skills determine the results of a game, the way we approach language—and our interactions with AI—shapes what emerges. Those who practice regularly, reflect thoughtfully, and observe carefully build a “bank” of experience that feeds meaningful outputs. Even the most advanced tool cannot replace this preparation; without it, results remain shallow. AI does not create independently; it mirrors the quality of what we bring to it. Similarly, a player’s skills, strategies, and daily habits define what they achieve in a game. Words, decisions, and outcomes are reflections of the effort invested beforehand. This principle extends beyond AI or gaming. Everyday life—our conduct in public spaces, engagement in online communities, and approach to creative work—follows the same rule. Depth of practice and attention to detail consistently determine the strength and quality of the outcomes we generate. In short, whether with words, games, or AI, the power of what emerges lies not in the tool itself, but in the thought, care, and engagement invested by the person using it.

This started as a side project because I was frustrated that supply chain data is either locked behind expensive Bloomberg terminals or scattered across 10 different sites.

What it does:

• Real-time oil tanker positions on a CesiumJS 3D globe using live AIS vessel tracking data

• Crude oil price feeds

• Chokepoint monitoring (Strait of Hormuz, Suez Canal, Malacca Strait, etc.) with traffic density

• Supply chain disruption alerts You can spin the globe, zoom into shipping lanes, and watch tankers move in near real-time. No signup, no paywall.

(http://supplychain.modelotech.com)

I built it with FastAPI and CesiumJS. If you're into geospatial data or logistics, I'd love feedback on what other data layers would be useful.

That moment genuinely freaked me out.

We casually paste sensitive data into AI tools, docs, chats… and just assume it’s handled safely.

I couldn’t find something I could actually trust, so I built this for myself:

A 100% offline text redactor with malicious link detection.
No cloud. No tracking. You can even use it in airplane mode.

It detects and removes API keys, passwords, tokens, credit cards, SSNs — and flags suspicious or malicious links — all on-device.

If you deal with sensitive data, this might save you one bad copy-paste.

MIT researchers have spent more than a decade studying techniques that enable robots to find and manipulate hidden objects by "seeing" through obstacles. Their methods utilize surface-penetrating wireless signals that reflect off concealed items. Now, the researchers are leveraging generative artificial intelligence models to overcome a longstanding bottleneck that limited the precision of prior approaches.

The result is a new method that produces more accurate shape reconstructions, which could improve a robot's ability to reliably grasp and manipulate objects that are blocked from view. This new technique builds a partial reconstruction of a hidden object from reflected wireless signals and fills in the missing parts of its shape using a specially trained generative AI model.

The researchers also introduced an expanded system that uses generative AI to accurately reconstruct an entire room, including all the furniture. The system utilizes wireless signals sent from one stationary radar, which reflect off humans moving in the space.

This overcomes one key challenge of many existing methods, which require a wireless sensor to be mounted on a mobile robot to scan the environment. And unlike some popular camera-based techniques, their method preserves the privacy of people in the environment.

These innovations could enable warehouse robots to verify packed items before shipping, eliminating waste from product returns. They could also allow smart home robots to understand someone's location in a room, improving the safety and efficiency of human-robot interaction.

"What we've done now is develop generative AI models that help us understand wireless reflections. This opens up a lot of interesting new applications, but technically it is also a qualitative leap in capabilities, from being able to fill in gaps we were not able to see before to being able to interpret reflections and reconstruct entire scenes," says Fadel Adib, associate professor in the Department of Electrical Engineering and Computer Science, director of the Signal Kinetics group in the MIT Media Lab, and senior author of two papers on these techniques. "We are using AI to finally unlock wireless vision."

Anyone in the uk use these locks and how do you find them and how well do they work with home assistant

I have a T2I workflow with three samplers.

First is 1024x1024 (NAI model / Euler A / Karras / 1.0 denoise).

Second is another pass after a 1.5X latent upscale (same as above but 0.5 denoise). Images look good but not realistic.

Third is a ZIT model focused on realism (with VAE = ae and CLIP = QWEN 3.4b). Just a single sample pass with 0.5 denoise. No loras. I did an XY plot with (Euler A, DPM++ SDE, DPM++ 2M) samplers crossed with (Simple, Karras, and DDIM-uniform) schedulers. The result was that all three samplers with either Simple or DDIM-uniform schedulers added the realism I was looking for. However, all three samplers with Karras failed to add realism ... in fact they failed to add almost anything at all.

I thought it might be the ZIT model so I swapped it out with a different ZIT model. Didn't help, same issue.

Then I thought maybe NAI and ZIT both using Karras was the issue. So I changed the NAI sampler to simple. Didn't help, same issue.

Anyone know why this is happening?

Hi! I am on my last couple of courses for my Payroll Compliance Practitioner program at the National Payroll Institute. I am hoping something has any prompts that they use for studying the material? Any help would be appreciated!

For context:

I'm working on an open source tool, "FrontCode", which is OpenCode, e.g., AI Coding Agent, but specifically built for front-end developers who want to ship dope UIs with AI.

I have seen even the best AI models and tools struggle with AI design, e.g., frontend code, and I want to fix it so developers can ship consistent web apps and/or world-class landing pages.

The tech stack is pretty straightforward since it's a fork of OpenCode:

1. TypeScript
2. Solid JS
3. Tailwind
4. Electron
5. Hono
6. Drizzle ORM

Since it's mostly an OpenCode fork, most of the bits and parts are already in place and ready for the desktop app. I'm looking for users or OSS contributors who can help make the tool better and take it from "just-a-tool" to "wow-what-a-tool".

If you are someone who has the same interest, I would love for us to collaborate and build this together.

This is a fully open source tool, NO browser extensions, NO installs required. I was mind blown I can't believe I haven't seen this covered by anyone other than some small channel with 800 subs and less than 500 views on the video, which is how I stumbled upon it: https://www.youtube.com/watch?v=C_C0MvJ1l6k

But here is the link:

https://siamsnus.github.io/GPT2Claude-Migration-Kit/
https://github.com/Siamsnus/GPT2Claude-Migration-Kit

I was able to completely migrate all of my memories and conversations (instructions didn't work for me but that may have been just me. But it's really easy to have Claude learn that pretty quickly, just keep using Claude and I feel this will resolve itself), and now Claude is my main AI tool. It's been a godsend being able to have all of my ChatGPT history from years and years all saved into Claude's memory.

Biyahe (bee-YA-heh) is the Filipino word for "journey" — I'm Filipino American and wanted to build something that reflected that. It's also just a really fun word to say.

The problem: Planning a trip to a new city is overwhelming. You open Google Maps and there are hundreds of pins. You check TripAdvisor and there's an endless list of activities with no sense of how they actually fit together into a real day.

The solution: Instead of building your itinerary from scratch, just see how someone else did it. Biyahe lets you browse real itineraries from real people who've actually been there — not AI-generated suggestions, not sponsored content. Real trips, from real travelers.

You can browse by city, see activities connected on a map, and modify any itinerary to make it your own.

It's live now, and I'd love for you to try it and tell me what you think, especially whether the core concept clicks, and where there can be improvements.

Here's the link: https://discover.biyahe.app/

A few weeks ago I published a paper showing that a STAR reasoning framework raised Claude's accuracy on an implicit constraint problem from 0% to 100% (arXiv:2602.21814).

Then I tested the exact same STAR framework inside a real production prompt — a 60-line system prompt from my interview coaching app that had grown naturally over months of development. Accuracy dropped to 0–30%.

The mechanism turned out to be surprisingly specific. The production prompt contained "Lead with specifics" and "Point first" style guidelines. These caused the model to output a conclusion before STAR reasoning could execute. In one case the model literally output:

"Short answer: Walk."

...followed by a complete STAR breakdown that correctly identified the constraint and concluded "Drive your car to the wash." STAR worked. The model reasoned correctly. But the wrong answer was already committed to.

The key finding: in autoregressive generation, once the model outputs a token, that token becomes part of the conditioning context. "Lead with specifics" triggered a premature commitment, and the STAR reasoning that followed was post-hoc rationalization.

Full follow-up paper: arXiv:2603.13351

Practical implication: if you're building production AI systems, validate reasoning frameworks inside your actual prompt, not in a clean 10-line test. A technique that scores 100% in isolation may score 0% in production.

Has anyone else run into reasoning degradation when adding instructions to an existing prompt?

Most AI memory systems have the same problem: they always answer, even when they have nothing useful to say. Ask about something that was never mentioned and instead of "I don't know," you get a confident wrong answer built from the closest random match in the vector store.

I've been thinking about this a lot while working on a memory layer for LLM agents. The core issue is that vector similarity search always returns results. There's no "nothing found" state. So the AI treats whatever comes back as real context and builds a confident sounding answer on top of garbage.

What if memory systems had confidence levels? Like, before feeding context to the LLM, you check: is this actually relevant or just the least irrelevant thing in the database? And then you give the AI different instructions based on that:

- High confidence: answer normally

- Low confidence: "I'm not sure about this, but here's what I found"

- No confidence: just say "I don't have that information"

Feels like this should be table stakes but most systems skip it entirely. They optimize for retrieval speed and accuracy but nobody asks "what happens when the retrieval has nothing good to return?"

The other interesting piece is user frustration. When someone says "I told you this already" that's actually useful signal. It means the system forgot something it shouldn't have, and you can use that feedback to boost the importance of whatever they're reminding you about.

How do you think AI should handle not knowing something? Always try to answer, or is "I don't know" actually the better response sometimes?

Hey everyone! I finally launched OneCamp.

It's a complete replacement for Slack, Trello, and Google Docs. Most people said building an 'all-in-one' tool as a solo dev was crazy.

It’s a one-time payment ($18). You host it on your own server. No per-user fees, ever.

I've made exactly one sale since March 9th. It's a slow start, but I'm proud of the tech. I'd love your feedback on the landing page and the 'One-time' pricing model.

Site: onemana.dev

I keep noticing how many small business websites feel super outdated especially on mobile or when trying to take action.

Not judging, most still “work,” but I wonder how many customers bounce because of it.

Do you think people actually care, or is a website just a placeholder at this point?

(I build websites so I notice this more, just curious what others think)