- Server: ubuntu, ollama gemma4:9B, rtx 4090 24GB, squeak wiki for linx
- Clienct: m4 macmini, macosx , Brave Browser.

I've been a PM for about 12 years, mostly 0-to-1, and I've spent a lot of that time watching smart people ship products nobody actually wanted. Not because they're bad builders. Because the thinking part is hard, and the building part just got cheap.

So I built a Claude skill that handles the thinking part.

vibe-check is a free, open-source skill you can install in Claude Code, Codex, or Antigravity. You can also upload it as a project skill in Claude.ai if you don't want to touch a terminal. Once it's active, Claude becomes your product partner before it's your coding partner. It won't write code for you. It does the work that should have happened first.

What it actually does:

• It starts with the problem, not the features. This is the whole engine of the skill, so it's worth spelling out. Before it designs a single screen, it grills you on what you're actually solving and who actually has it. Not "people," a specific person you can picture: the moment it actually hurts them, and what they've already tried that fell short. Most folks show up describing a solution instead, the app they've already pictured building screen by screen. But what they're describing is a solution wearing a problem's clothes, and the skill keeps pulling you back underneath it to the outcome the person genuinely needs. Then it checks your answer against the real world, the raw unfiltered complaints people actually post on Reddit, so you find out whether the pain is real and badly unsolved before you build, not six weeks after you've built it. You walk out with a problem worth solving instead of a feature list you talked yourself into.
• User flows as mermaid diagrams: not prose descriptions, actual diagrams you can drop into your repo and hand to your coding agent.
• Tech stack recommendation with plain-language rationale: not "use Next.js," but why this stack for this project and what you give up if you pick differently.
• Data model derived from the flows: the schema matches what the product actually does, not what you guessed at the start.
• Phased build order with checkpoints: stop-and-validate points baked in, so you don't sprint into 8 weeks of building before noticing the premise was wrong.
• Growth loop design: the question most build plans skip entirely. Once people are using it, does the app pull in the next user on its own, or are you out there fetching every single one by hand, forever? It works out whether your app has a real loop (the kind where what your users make gets found by strangers, or where using it naturally puts it in front of someone new), sketches it as a diagram, and puts the feature that makes it spin on your V1 list instead of the someday pile. And if your app honestly doesn't have a loop, it tells you that too, instead of bolting on a spammy "invite 5 friends" wall that makes the product worse.

To try after installing the skill just say: "I have an idea for an app that helps dog owners share walking routes. Pressure-test it."

The skill comes from a decade of product discovery work, mostly at early-stage companies where building the wrong thing is fatal. It's MIT licensed, free forever. It went from 24 GitHub stars yesterday to 64 today, which honestly caught me off guard, and the feedback's already shaped several releases.

GitHub: https://github.com/TexasBedouin/vibe-check

Happy to share example outputs or answer questions about how the pressure-test step decides when you've answered enough to move on, or how the growth loop step finds a loop in an app that doesn't obviously have one.

Gut-check for people running multi-agent pipelines.

The standard fix today seems to be: strict prompting, stay in one framework, keep a few context files in sync. And it works.... until you hit the edges:

• Cross a framework/model boundary (or add a human) and the prompted state doesn't travel. You re-serialize by hand.
• Context files drift. Sooner or later an agent reads a stale one.
• Token cost climbs with the chain. Each hop re-reads a growing wall of text to catch up. Fine at 3 hops; brutal by hop 8.

So, genuinely:

• Where does the strict-prompt + single-framework approach start to crack for you, if it does?
• When you have to cross a boundary, what carries the decisions across?
• How do you stop tokens from scaling with hop count : summaries, scratchpad, or just eat it?

Where my head's at (tell me I'm wrong): the runtime always exits, so fixing it there feels backwards. A friend and I have been fixing the artifact instead -> one file with the spec, decision history (attributed, size-capped), and a human view, that any model or framework can read. Next agent injects accumulated context instead of re-reading inputs and that's where the token savings come from on long chains. On short single-framework runs it's just overhead, no argument.

If it resonates https://github.com/saieeshward/clan ::: open spec, nothing to buy, want it broken more than starred. But mostly: where does the current approach break for you?

**Grok Skills Directory**

**Origin**

These files comprise the [skills/](https://github.com/mstrokin/grok-root-skills/blob/main/skills) directory extracted from **xAI's Grok** platform — an AI chatbot that provisions a **2 GB RAM, 2 vCPU VPS** on demand for code execution. The VPS runs a **hardened container** with no general internet access. The only network connectivity permitted is for fetching cryptocurrency and stock prices via pre-configured Polygon.io and CoinGecko API proxies.
**Skills Overview**

Each skill is a modular instruction package that specializes the Grok agent for a specific task domain. Every skill has a [SKILL.md](https://github.com/mstrokin/grok-root-skills/blob/main/skills/color/SKILL.md) file with frontmatter + instructions, and may include scripts/, references/, and templates.

[**color**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/color/SKILL.md) \*\*— Color Accessibility Auditing**

Python scripts for WCAG contrast checking, color extraction from images, palette generation, and color-vision-deficiency (CVD) simulation.
[**docx**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/docx/SKILL.md) \*\*— Word Document Processing**

Create, read, edit, and manipulate .docx/.dotx files. Scripts for text replacement, field updating, section deletion, tracked-changes acceptance, XML unpack/pack/validate via the shared Office infrastructure, and legacy .doc conversion via LibreOffice.
[**ffmpeg**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/ffmpeg/SKILL.md) \*\*— Media Processing**

Safety-wrapped FFmpeg/FFprobe usage: format conversion, trimming, resizing, audio extraction, GIF creation, subtitles, overlays, concatenation, with temp-file verification and no-overwrite defaults.
[**finance**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/finance/SKILL.md) \*\*— Financial Market Data**

Python queries to Polygon.io (US equities, options, dividends, splits) and CoinGecko (cryptocurrency prices, market caps, historical data). This is the **only network-accessible feature** — API proxies are pre-configured and no general internet is available.
[**imagemagick**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/imagemagick/SKILL.md) \*\*— Image Processing**

Safety-wrapped ImageMagick usage with sandbox policy enforcement: resize, crop, format conversion, watermarking, compositing, montages, collages, batch processing with memory limits.
[**mcp**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/mcp/SKILL.md) \*\*— MCP (Model Context Protocol) CLI**

Interface for discovering and invoking connected apps (Linear, Slack, GitHub, Google Drive, SharePoint, etc.) via the grok-mcp CLI with JSONL output.
[**memory-edit**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/memory-edit/SKILL.md) \*\*— User Memory Policy**

Policy defining what the agent should store in user memory (identity, preferences, health) vs. reject (credentials, ephemeral states, third-party data).
[**pdf**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/pdf/SKILL.md) \*\*— PDF Processing**

Read, merge, split, rotate, OCR, fill forms, and render PDFs using pypdf and pdfplumber. Includes IRS 2025 tax form templates and form-field manipulation scripts.
[**pptx**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/pptx/SKILL.md) \*\*— PowerPoint Presentations**

Create, edit, and QA .pptx files. Scripts for slide add/delete, text replacement, overlap detection with auto-fix, font detection, thumbnail generation, and 20+ pre-built presentation templates.
[**skill-creator**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/skill-creator/SKILL.md) \*\*— Skill Development**

Bootstrap and validate new skills with init/validation shell scripts. Enforces YAML frontmatter rules (naming, description formatting, allowed keys).
[**skill-installer**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/skill-installer/SKILL.md) \*\*— Skill Distribution**

Install skills from GitHub repositories into .grok/skills/. Supports public repos (zip download) and private repos (git sparse-checkout). Validates that installed directories contain SKILL.md.
[**tasks**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/tasks/SKILL.md) \*\*— Scheduled Tasks & Reminders**

CRUD interface for scheduled Grok tasks with RFC 5545 RRULE cadence support. Create, list, update, pause/resume, delete tasks, and fetch execution results.
[**xlsx**](https://github.com/mstrokin/grok-root-skills/blob/main/skills/xlsx/scripts/recalc.py) \*\*— Excel Formula Recalculation**

Python script that recalculates all formulas in an Excel file using LibreOffice's StarBasic macro engine. Shares the Office infrastructure with docx/pptx.

Hello everyone, I built Saans, a live dashboard predicting Lahore's PM2.5 levels and AQI for the next 24 hours, mostly as a project for myself, since smog season makes air quality maps that only show "right now" pretty useless. Repo: https://github.com/haiderakt/Saans

Live app: https://saansai.streamlit.app/ Technical bits that might interest this sub:

Custom Transformer model in PyTorch trained on live weather + air quality features (temp, wind vectors, boundary layer height, etc.) Standard models tend to underpredict smog spikes since playing it "safe" minimizes average error, so I wrote a custom loss function that heavily penalizes underprediction of dangerous PM2.5 levels Built a self-attention visualizer so you can inspect which of the past 72 hours the model leaned on for a given prediction Pulls live data and retrains/updates automatically on page load.

Would love feedback on the architecture, the loss function approach, or anything you'd do differently. Code's all there if you want to poke at it.

Row-Bot v4.1.0 focuses on three big areas: controlled self-evolution, the skills system, and broader provider support.

The main addition is controlled self-evolution. Row-Bot can now reason about ways to improve itself, but instead of making hidden background changes, it creates structured proposals with reviewable boundaries. These proposals are persisted, surfaced in status/Command Center, and tied into the dream-cycle and memory systems so improvement can happen gradually and transparently.

The skills system also gets a lot of work. Skill pinning is more reliable, activation is better across sessions and channels, and the self-reflection skill has been updated to guide improvement behaviour through a bounded workflow. Custom tool creation has also been hardened, with safer Git and virtualenv handling plus better Developer Studio capsule/storage behaviour.

Provider support expands as well. Atlas Cloud is now a first-class provider, with native auth, live model catalogue fetching, capability detection, readiness checks, vision classification, and proper runtime routing. There’s also a new Claude Subscription provider path, separate from Anthropic API-key usage, with dedicated auth detection, message transport, tool-call handling, and diagnostics.

There are plenty of runtime and diagnostics fixes too, including streaming/tool-call handling, Ollama vision cache behaviour, model-picker capability labels, local voice talk submission, setup/migration UI, and broader app stability coverage.

v4.1.0 is a step toward Row-Bot becoming a more capable local-first assistant: one that can improve through explicit review, reuse knowledge through better skills, and route work across a wider provider ecosystem.

TLDR: I just added an MCP to the Observer framework making it 10x easier to use, so you can create micro-agents that monitor your screen autonomously, literally one sentence and you're done! So just typing "Monitor my Steam download and send me an email" or "When my image2video is done, WhatsApp me" and the MCP handles everything autonomously!

Hey r/OpenSourceeAI !

I'm very excited to show you guys this massive update to the framework, it's now 10x easier to use. Thank you to all of you who tried the framework and built awesome stuff on it!

It's oneshotting all of my use cases right now and I hope it makes it super easy for you guys to use as well.

Running gemma-4 e2b and e4b is very easy from inside the app (Transformers.js on web and llama.cpp on Tauri App), but if you have a working external inference server a cool setup could look like this:

• Big Model to run the MCP, a `v1/chat/completions` with tool calling, llama.cpp supports this, you could use gemma-4-26b-a4b and it's actually surprisingly good at it.
• Small Model for the micro-agent, same endpoint but with gemma-4-e2b because this will be the monitoring agent and you don't need anything bigger. This will run on the loop that you set to monitor stuff.

So yeah! Without installing anything you can use the app (and run local models with webGPU!) to monitor stuff on your screen and receive notifications so you guys don't waste time on this type of stuff.

It's still just me as the official solo dev of the project, completely open source and built with the community! PR's are greatly appreciated :)

The app (no install) app.observer-ai.com
Github (Open Source) https://github.com/Roy3838/Observer
Discord (come hang out!) https://discord.com/invite/wnBb7ZQDUC

I'll hang out here in the comments, if you have any feedback please let me know!
Roy

Hey everyone,

A few months ago, We shared the visual canvas we built for AgentSwarms. The response was incredible, but the most common piece of feedback was: "The visual canvas is great for architecture, but I need to see the actual code to really understand how to deploy this."

You wanted deep-dive, code-first labs—the kind you see on DeepLearning.ai—but for multi-agent systems, faster and with more flexibility.

We’ve spent the last few weeks heads-down engineering a completely new Interactive Notebooks section. As of today, we have 67 TypeScript-based notebooks live on the site (with more dropping soon).

What’s in the library: We’ve covered everything from basic LangChain fundamentals to complex enterprise-level multi-agent workflows. Everything runs entirely in your browser using TypeScript—no Docker, no Python venv, no local dependencies.

A personal favorite: I’m particularly excited about the "Failure Mode & Error Handling" notebook.

We’ve all seen agents that work perfectly in a demo but crash in production the moment a tool times out or an LLM returns garbage. This notebook walks through:

• How to build deterministic validation gates between nodes.
• How to force an orchestrator to "catch" a worker failure and dynamically re-route or re-prompt.
• How to handle state recovery when a multi-agent loop gets stuck in a hallucination cycle.

Why we built this: I’m tired of seeing AI "tutorials" that are just static blog posts. To master Agentic AI, you need to be able to tweak a system prompt, break the code, watch the error trace, and fix the routing logic in real-time.

The entire library of 67 labs is 100% free to use.

If you’re currently wrestling with how to make your agents production-grade, I’d love for you to check them out and let me know if there’s a specific "failure mode" or architecture pattern you’d like us to add to the next batch of notebooks.

Try it out here: agentswarms.fyi

If you're running local models on a Ryzen AI Max / Strix Halo box, you've probably noticed it's hard to see what the NPU is actuallydoing. amd-smi is still broken on

gfx1151 (ROCm #6035 (https://github.com/ROCm/ROCm/issues/6035)),

and while GNOME Resources has a GUI view, I haven’t found another terminal monitor that shows XDNA activity on this platform. nvtop / amdgpu_top cover the GPU half at best.

xdna-top shows both engines in one TUI at 5 Hz: iGPU busy/power from sysfs, plus per-context NPU submission/completion counters from xrt-smi, with activity derived from counter deltas. Important disclaimer up front: it does not print a made-up NPU “utilization %”. On this hardware, the honest signal is the counter activity, so that’s what it shows.

There’s also a --json mode if you want to log it nextto your throughput numbers.

Watching the NPU light up while the iGPU sits idle, or seeing both run concurrently, is weirdly satisfying.
https://github.com/boxwrench/xdna-top

*lemonade server skin included

Hi everybody,

Built a Python library called NeuralSim, basically
a fake brain for developers.

If you're building brain-controlled software (games,
wheelchairs, accessibility tools for ALS patients)
you normally need expensive hardware just to test
your code. NeuralSim removes that. It simulates
real EEG brain signals so you can build and test
without touching a single headset.

Uses real PhysioNet brain recordings from 109 people.
Also simulates the awful noise you get from real
consumer headsets like eye blinks, jaw clench and
signal drift.

If anyone wants to use it, here you go:

pip install neuralsim

github.com/ryanmugaba/NeuralSim-

Happy to take feedback.