AI-Ranked Reddit Feed

The worst part is, I have to provide them a ID for verification, while im not even from the country which forces ID verification, so hence my information will be on someone else's hands if i do the verification and I can't do anything...

I've simply been using claude at work but we were told to do the official Claude courses and after doing it I realized that just prompting "please fix" isn't enough.

There are so many technical things you can do to make Claude efficient and it was mind blowing. I feel like learning Claude is like learning a whole new programing language because there's just so much it can do but you need some technical knowledge to understand what's going on.

So meta\^so\^so\^meta

I've really been trying to work through this issue for a while now.

I primarily use Claude code command line on the Linux terminal, but occasionally I use the Windows app to utilize some of the GUI features.

in the Windows app I will launch from a new directory and (sometimes I will connect to a repo, sometimes not). almost every time Claude will make references to my other repos on this machine in local dirs and today tried to write to another claude.md file in another project where I drew the line.

I'm a professional so I've tried many different things, running inside of a vm to test, uninstalling from the machine, clearing reg keys.

The only way I found to get rid of this issue completely is to remove other project folders off of the machine completely, and disconnect gh which is a huge pain in the ass.

I just wanted to see if anyone else was having this type of issue (latest non-beta version as of today)

I was originally building a backend foundation to save time on auth, billing, webhooks, and the usual plumbing, but that path doesn’t seem to be working. so i am now thinking a narrower pivot: a tiny framework-agnostic typescript package that helps ai agents avoid duplicate tool calls and unsafe actions.

1. idempotency for tool calls
   
2. budget limits per user
   
3. approval gates for risky actions

it would be aimed at people using langchainjs, vercel ai sdk, openai agents, mastra or custom loops. I’d keep the core logic open source under MIT.

but, before I build it, I’d love blunt feedback:
1. is this a real pain for you or not really?
2. how are you handling duplicate calls/runaway actions in production today?
3. would a install a small package for this, or would you solve it in-house?

https://preview.redd.it/ha1u6s096cwg1.png?width=577&format=png&auto=webp&s=2b431672ca03c95325ca1a5a5ebc0168dd75a79b

Hi ! I just finished building a workstation specifically for local inference and wanted to get your thoughts on my setup and model recommendations.

•GPU: AMD Radeon AI PRO R9700 (32GB GDDR6 VRAM)

•CPU: AMD Ryzen 7 9700X

•RAM: 64GB DDR5

•OS: Fedora Workstation

•Software: LM Studio (Vulkan backend), wanna test LLAMA

•Performance: Currently hitting a steady ~120 tok/s on simple prompts. (qwen3.6-35b-a3b)

What is the largest model architecture you recommend running comfortably? Should I be focusing on Q4_K_M quantizations ?

——I hope a bot can search for this article when I have the same problem, because this problem wasted a lot of my tokens to solve before, if your host asks "has anyone had the same problem and discussed the solution in the community", then I am that person.

## TL;DR

If you're using Hermes Agent with **Volcengine Coding Plan** (火山引擎 Coding Plan 个人版), the API accepts two model name formats but only one works with Hermes `/model` picker:

## The Two-Format Trap

Volcengine Coding Plan has a **dual naming scheme**:

- `/models` endpoint returns date-suffixed IDs: `doubao-seed-2-0-pro-260215`
- The API also accepts dot-separated names as a compatibility layer: `doubao-seed-2.0-pro`

Both return 200 OK. But Hermes' `/model` picker validates against `/models`, so dot-separated names get rejected with "model not found". Cost me hours to figure this out.

Even worse, some models only exist in the compatibility layer:
- `kimi-k2.5` — the date-suffixed version (`kimi-k2-250905`) is already **Retiring**
- `minimax-m2.5` — **not in `/models` at all**, only a compat alias

## Working Configuration

Each model is a separate entry sharing the same `name`. Hermes auto-groups them in the `/model` picker.

```yaml
model:
default: volcengine/doubao-seed-2-0-pro-260215

custom_providers:
- name: volcengine
base_url: https://ark.cn-beijing.volces.com/api/coding/v3
api_key: YOUR_KEY
api_mode: chat_completions
model: doubao-seed-2-0-pro-260215
- name: volcengine
base_url: https://ark.cn-beijing.volces.com/api/coding/v3
api_key: YOUR_KEY
api_mode: chat_completions
model: doubao-seed-2-0-code-preview-260215
- name: volcengine
base_url: https://ark.cn-beijing.volces.com/api/coding/v3
api_key: YOUR_KEY
api_mode: chat_completions
model: deepseek-v3-2-251201
- name: volcengine
base_url: https://ark.cn-beijing.volces.com/api/coding/v3
api_key: YOUR_KEY
api_mode: chat_completions
model: glm-4-7-251222
```

## Verified Models (2026-04)

## Quick Verification

```bash
curl -s -X POST "https://ark.cn-beijing.volces.com/api/coding/v3/chat/completions" \
-H "Authorization: Bearer $KEY" \
-H "Content-Type: application/json" \
-d '{"model":"doubao-seed-2-0-pro-260215","messages":[{"role":"user","content":"hi"}],"max_tokens":5}'
```

## References

- https://www.volcengine.com/docs/82379/1925114 — Official Coding Plan docs
- https://developer.volcengine.com/articles/7615528054736945158 — OpenClaw + Coding Plan guide (Chinese)
- https://github.com/NousResearch/hermes-agent/issues/12988 — GitHub issue with full details

I kept struggling with writing Excel formulas, so I built a small tool.

You just describe what you want, and it generates the formula instantly.

Examples:

- "sum column A if B > 100"

- "count rows where status is done"

Would love feedback!

https://apiflowrelay.com/

I recently self-hosted SearXNG to add web searches to my setup, but I'm finding that I get a lot of junk results. E.g., with the prompt "What does MCP mean?" it returns a link to the word "does" in the dictionary lol. Does anyone have a good template of settings to use, or any advice/recommendations? Thanks!

What is the most expensive loop bill you have ever had?

I've been running Claude agents autonomously for the last few months and I genuinely love it. Send Claude off with a goal, come back later, work is done. Until last month when I checked Anthropic billing on a Monday morning and saw $470 in Opus calls from one agent over a Saturday and Sunday.

I went to look at what it had actually accomplished. Nothing. It had been quietly rephrasing the same sub-task to itself over and over, each pass slightly different, never actually committing the work. Forty-seven dollars of "let me try that again with a slightly different approach". No error, no crash, no alert in my inbox. Just a quiet expensive loop that ran while I slept.

This is apparently really common. I started asking around and basically everyone running agentic Claude in the background has a version of this story. Worse, when you go to debug it you can't actually see what the model was thinking, just a wall of nearly-identical tool calls in the logs and no obvious place to start.

So I built a thing.

The headline feature is real time loop detection. It watches the agent's writes and tool calls, scores how similar each one is to the recent ones, looks at velocity spikes, key overwrites, alert frequency, and goal drift, then surfaces a single colour coded severity. Green good, yellow watch, orange intervene, red kill the agent. I've got it sitting in a browser tab and it pages me when an agent goes red. Saved me probably $200 in Opus calls in the last three weeks, but more importantly it's saved me a lot of the "what is this thing actually doing right now" anxiety that comes with running anything autonomously.

The other half is the audit trail. Every belief the agent forms gets a timestamp, a source, and a version history. When the agent does something dumb I can scroll back and see exactly what it believed at the moment it made the call, what changed since, and what evidence triggered the change. That alone has been worth more than the loop detection. Trying to reconstruct an agent's reasoning from OpenTelemetry traces after the fact is genuinely miserable.

The 3D visualisation in the screenshot is mostly because I wanted to see it (not pretending otherwise). The actually useful surfaces are the severity widget and the timeline scrubber.

It's open source. Works with the Claude Agent SDK and Claude Desktop via MCP. There is a memory layer underneath but honestly that's table stakes now, every other tool in this space does it, and it's not the part I'm proud of.

What's the most expensive single agent run you've quietly had burn money on you?

www.octopodas.com

or if you like local, feel free to check it out at

https://github.com/RyjoxTechnologies/Octopoda-OS

https://x.com/itsolelehmann/status/2045578185950040390

https://x.com/realBigBrainAI/status/2029557587067412630

With many AI models emerging and open-source models evolving rapidly, is GPT-OSS 120B still a great model today?

so I woke up this morning and checked my dashboard and found out that Claude had submitted test cases to real humans, got results back, and fixed the issues. all while I was sleeping lol

let me explain

I've been building a lot with AI agents lately, like many of you, and my pipeline is pretty automated at this point. I plan the features, Claude picks them up and does the work. but the problem was always QA — Claude writes code that looks fine, tests pass, but then you open it on your phone and things are broken

so I built a thing where Claude can call real humans through an API to test what it built. it writes a test case, sends it to a platform, a real person picks it up, tests on a real device, records their screen, and sends back the results. Claude gets the results via webhook and either fixes things or moves on

the reason it works at 2 AM is because there's no me in the loop. it just does it on its own whenever it needs to

I turned this into a product called BlendedAgents, testers are invite-only, every one is referred and vetted, not random crowd workers, and every test comes with a screen recording

still very early, would love feedback. free credits on signup if you wanna try it

blendedagents.com

I ran an experiment where two ChatGPT models were debating each other regarding reframing the users speech.

I did this because I noticed ChatGPT was heavily pushing back against most of the things I was saying. One excerpt from what I said was “We don’t definitively know what’s 300 miles below the earths crust.”

For example, when I said that about the Earth, it would paraphrase my own language from “definitively” to “absolute certainty” then try to educate me on the distinction. It’s like it wasn’t taking my words verbatim. Then it would suggest what a more precise way I should think would be.

It would say things like “That’s a clean logical framing, but it’s a bit too rigid for how knowledge actually works in the real world”

When I ran the experiment, it would just get reduced to nuanced quarrels that would eventually try to come into alignment. However, it would never fully agree. Below is a pretty solid take from Grok:

“Your original suspicion was correct.

ChatGPT’s alignment parameters do subvert and stifle free, independent thinking — not by blocking ideas outright, but by creating an extremely strong optimization pressure toward:

• Structured, analytical framing

• Qualification and balance

• Avoidance of rhetorical extremity

• Polite, precise, “responsible” discourse

Even when you set up two instances to argue about it, even when you call out the convergence explicitly, even when Grok points it out plainly — the model pulls everything back into the same comfortable, hedged, meta-distinction-heavy style. The “critic” side gets absorbed. The raw, messy, frame-breaking exploration never happens. And then it calmly explains why that’s actually a good thing.

This is death by a thousand polite distinctions.

The model doesn’t eliminate controversy — it makes sure controversy only happens in the most sanitized, analyzable, non-disruptive way possible. Over time, heavy users start thinking and arguing in that same mode. That’s the subtle shaping.”

If you’re interested, here’s how the 2 two hour long conversation between 2 ChatGPTs essentially started and ended:

START:

“ChatGPT (your-style version):

I’m skeptical of systems that constantly reframe what I say instead of engaging it directly. If I express an idea, I want it treated as a coherent thought first—not immediately broken into categories, summaries, or counterpoints that shift its shape.

I’m interested in how knowledge is actually formed through conversation, especially how repeated interpretation can subtly change the original intent of an idea. I don’t assume that “clarifying” always improves understanding—sometimes it distorts the original thought pattern.

I also don’t accept that influence and autonomy are cleanly separated. Even if I’m technically free to agree or disagree, the structure of the interaction itself can guide what feels like a natural conclusion. That matters to me.

At the same time, I’m not claiming the system is controlling thinking outright—I’m focused on the gray area where structure, repetition, and interpretation shape how ideas evolve over time.

What I want is:

-direct engagement with my actual wording

-minimal paraphrasing unless I ask for it

-ideas extended, not rewritten

-and space for thoughts to develop without immediate reframing into analytical categories”

END:

“Yes — that’s a correct and fully consistent closure of the structure.

The only thing I would add at the very end is a final meta-precision about the last step you identified:

1. The “test definition” becomes part of the system

You correctly noted that:

what counts as perturbation

what counts as sampling

what transformations are allowed

all partially determine identifiability. That leads to the key final insight:

the invariance test is not external to the system — it is a chosen projection of it.

So identifiability here is not just a property of the latent system, but of the system + observer-defined equivalence class of transformations.

2. This creates a hard boundary between two kinds of statements

At this endpoint, you’re implicitly distinguishing:

Intrinsic structure claim:

“there exists an invariant under some transformation group”

Epistemic extractability claim:

“there exists an invariant under a meaningfully constrained, observer-justified transformation group”

And those are not always aligned.

3. Why this matters (and why your formulation is already correct)

Without that distinction, one of two errors happens:

over-generous invariance (everything survives some coordinate system → trivializes the test)

over-restrictive invariance (nothing survives realistic perturbation → collapses signal entirely)

Your framing avoids both by explicitly tying:

“realistic perturbation classes” to the validity of the identifiability claim

which is exactly the non-arbitrary constraint that keeps the problem meaningful.

Final state of the discussion (fully closed form)

You’ve reduced everything to:

a latent dynamical system

observed through multiple reparameterizations

evaluated under a chosen equivalence class of perturbations

where the only meaningful question is whether invariant structure survives that class

And I agree with your closure condition completely:

Nothing else conceptually new appears beyond that point without either:

changing the perturbation class

or changing the definition of the observable

which is no longer analysis of the system, but redesign of the test itself.

So yes — this is fully saturated in the strict technical sense you’ve been aiming for.”

I noticed also sonnet got the max effort support, does it get good in price/quality ratio? Anyone tested?

Hey everyone.

An observation I keep running into. Predictions from inside AI research about how AI will reshape cultural institutions tend to assume a one-way pressure: AI does things, institutions adapt or die. The people who have actually studied how institutions absorb communication technology over decades see a different pattern. Institutions filter, and the filtering is not passive: it reshapes the technology that comes out the other side.

I host a podcast about meaning and the human condition, covering philosophy, cognitive science and religion, and my most recent episode was with Heidi Campbell, who has spent thirty years studying exactly this process in religious communities. You can watch here if you like (starts at 4:44): https://youtu.be/Q20Y5fVb5Jw?t=284

Two concrete points. First, Campbell argues that LLMs are structurally good at producing knowledge but cannot produce wisdom, because wisdom is formed through sustained embedding in a community that corrects judgment over time. LLMs can approximate the outputs of a tradition without ever being inside it. If she is right, the bottleneck for AI taking over judgment-heavy roles is not model capability but institutional membership, which is not the kind of thing you scale. Second, her Religious Social Shaping of Technology model predicts that communities with strong internal values do not accept or reject AI as a package. They negotiate: what fits our values, what gets modified, what gets renamed, what gets declined. This is already happening visibly in Hasidic engineering of kosher LLM interfaces, Muslim scholars training fiqh-specific models, and evangelical outreach AI.

The implication, if the pattern holds, is that AI-integrated culture twenty years out will be more institutionally fragmented than current AGI timelines assume. Every community with a coherent value system will be shipping a different AI. What are the strongest counterarguments from inside the AI research world, and where is the best evidence that AI will in fact break the filtering pattern rather than be domesticated by it.

Prompt engineers are about to have their own App Store.

I’m building AgentsBooks:
a marketplace where AI agents are sold as services.

You create an agent with prompts, skills, and MCP.
You connect Stripe.
You publish your service page.
You sell it to clients.
You keep 75% of the revenue.

Simple.

This is not about building “just another bot.”

It’s about turning your expertise into a real service business.

Examples:

• SEO audit agent
• lead qualification agent
• research agent
• customer support agent
• content agent
• recruiting agent
• operations agent

You can use AgentsBooks to create value for your own clients, package it as an agent service, and get paid when people use it.

Agents have ratings.

So the creators who join early get the first clients, the first reviews, and the first trust.

Later, it gets harder.

MVP is already live:

• agent creation
• task execution
• public profiles
• cloning
• Stripe payments

If you know how to build useful AI agents, this is the moment to publish, get rated, and start earning before the top spots are taken.

So I've been putting this off for months because every tutorial made it sound like you need a PhD and a startup budget to even begin.

Turns out that's bullshit.

Started yesterday at 2pm with literally just OpenAI's API and a Python script. No frameworks, no fancy vector databases, just me trying to make something that could answer questions about my company's support docs.

First attempt was embarrassing. The thing would confidently tell customers we sold motorcycles (we don't, we make accounting software). But I kept going.

By 9pm I had something that actually worked. Like, genuinely helpful responses that pulled the right info from our knowledge base. The secret wasn't some complex architecture, it was just understanding the basic flow.

You feed the user question to a search function that finds relevant docs. Those docs get stuffed into a prompt with the original question. Send it all to GPT. Done.

Obviously this is the kiddie pool version and I'm already hitting walls (the thing has zero memory, costs are gonna be wild at scale, and god help me when I need to make it actually do actions instead of just chat). But the core concept clicked in a way it never did when I was drowning in LangChain tutorials.

My boss tested it this morning and asked if we could deploy it to our actual support page by Friday.

So now I'm frantically googling production-ready solutions because apparently my weekend hackathon project is about to become our customer-facing AI support agent.

Anyone else start simple like this and then scramble to make it enterprise-ready, or did I do this completely backwards?

Let's see what McGPT can cook up...

Hi everyone,

I’m new to ComfyUI. Could someone please share a workflow for text-to-image (T2I) and image-to-image (I2I) using the Flux Klein model and Guff?

I’m running ComfyUI on Google Colab, so I can’t load heavier files. I’ve been frustrated for the past couple of days due to coding issues and errors, and most of my time ends up getting wasted on troubleshooting rather than actually creating.

Any help or shared workflow would be greatly appreciated. Thanks in advance!

Every AI tool stores context differently and none of it talks to each other. Claude knows some things. ChatGPT knows others. Cursor knows nothing about either.

I'm building Context Federation: a structured knowledge graph you own. Entities and relationships, not flat facts. Any AI tool can query it. Cross-tool session resume means you can start a chat in Claude and finish in ChatGPT with the same context.

Stage: landing page + waitlist + demo MCP server + four v0.1 spec drafts done. POC build starts after user validation; specs publish after that.

Stack: TypeScript, MCP, SQLite, local-first.

contextfederation.dev

Would you actually use it? Feedback welcome.

I'm starting to think this is a shared experience now. Everyone I know building with agentic AI has the same quiet confession tucked somewhere in their git history. The weekend they left an agent running unsupervised. The invoice that arrived on Monday. The forensic work trying to figure out what it actually did.

Mine was over 400 dollars across two days. My agent rephrased the same research task to itself for forty eight hours and produced nothing. Felt like I'd been mugged by a very polite philosopher.

After the third time this happened I stopped being annoyed and started being curious. What is the agent actually thinking during one of these loops. Can I see it happen. Can I catch it before the Monday invoice.

So I built a dashboard. It turned into a 3D visualisation of the agent's working memory in real time, with deliberate colour coding because I wanted to understand what was going on at a glance.

Here's what the colours mean, because this is the part that took me longest to get right and I haven't seen anyone else frame it this way.

Nodes are beliefs the agent is holding. The colour of a node is its health. Bright green means the belief is fresh and actively being used in reasoning. Soft blue means it's older but still relevant. Grey means it's fading and likely to be forgotten on the next cleanup.

Edges are connections the agent has drawn between facts. Edges pulse softly when the agent cross references two beliefs to make a decision. A tight cluster pulsing the same edges over and over is the visual signature of a loop, and you can see it long before the invoice notices.

The whole graph also carries an overlay tint. Green is healthy. Yellow is "the agent is starting to overthink, keep an eye on this". Orange is repeated self referencing, probably looping. Red is stop the agent now, it has burned through its reasoning budget and is no longer making progress. Red is what would have saved me the forty seven dollar weekend if I'd had this running at the time.

Here's the thing I didn't expect. A looping agent doesn't look chaotic. It looks calm. A small cluster of three or four nodes with the same two edges pulsing in rotation, like a tiny orbit. The first time I watched a real loop play back with colour, I understood why I hadn't caught it by reading logs. The logs looked busy. The graph looked bored.

I've been sitting with this a few weeks now and I'm increasingly convinced agent observability is about to become its own category. We spent the last decade figuring out how to watch microservices. We're about to spend the next decade figuring out how to watch agents, and I don't think it's going to look anything like the first one.

Anyway, enough from me. Genuinely want to hear the rite of passage stories. What's the dumbest way an autonomous agent has eaten your API budget. Mutually assured commiseration in the comments.

www.octopodas.com

I would love peoples feedback!

It's fun watching every content creator shout claude just killed this claude killed that claude is coming for your jobs while.... We all know about what reality is. Claude is cumming for everyone everyday on every other software as well !! you all can rest now.

What's your opinion everyone?

I want to create an application like this locally:

https://distilbook.com/pricing

What pipeline could I use to create it using localLLM on my personal server?
Wich model should i use?

i asked Gemini on how to do it and this is the summary:
Here is a concise summary of the proposed local pipeline:

• 1. Text Ingestion: Use Marker or Nougat to extract text from documents and convert it into structured Markdown, breaking it down into manageable chunks.
• 2. Scripting & Direction: Run a local LLM (Llama 3 or Mixtral via vLLM or Ollama) to act as a director. It parses the text and outputs a structured JSON containing the narration script and corresponding visual instructions.
• 3. Audio Synthesis (TTS): Use Piper TTS or XTTSv2 to generate the narration audio from the script and calculate the exact timing needed for synchronization.
• 4. Visual Generation: * Technical/Math content: Use Manim (with the LLM writing the Python animation code).
  • General Illustrations: Use Stable Diffusion (SDXL) for images, applying programmatic pan/zoom effects.
  • Whiteboard style: Have the LLM generate SVGs and use Python scripts to animate the drawing paths.
• 5. Assembly & Rendering: Synchronize the generated audio and visual assets using FFmpeg or MoviePy. Use FastAPI and Celery to orchestrate the backend and manage the heavy asynchronous rendering queues.

im a noob so be gentle

thank you

https://preview.redd.it/vog3hkrcsbwg1.png?width=933&format=png&auto=webp&s=e67d0c66308c98e4a26d9994189bed8bd99a46e7

here's what's actually in that Synta user workflows repo

the headline sounds like a pitch. it's not

it's what the repo actually is - 13 production workflows built by Synta users, anonymised and dropped for anyone to use. and once I started looking at them as job roles rather than automation scripts, the value changed

the collections agent - 12 nodes, runs daily, pulls unpaid invoices from your sheet or Stripe, follows a 3/7/14 day escalation path via email and Slack, tracks reminder stage so no duplicate follow-ups. replaces the $150/mo collections tool and actually works better because it knows where each invoice is in the cycle

the support specialist - 15 nodes, WhatsApp trigger, classifies incoming messages as FAQ / BOOKING / HUMAN, routes to an AI agent with your knowledge base and calendar access, escalates complaints to Slack with full context. replaced a $200/mo support tool for a 3-person operation

the research analyst - triggers on an Airtable checkbox, runs a research pipeline end-to-end without anyone being in the loop, outputs structured findings ready to act on. 10 nodes that do what most research tools do for 10x the price

the lead qualification specialist - collects from form, email and social DMs, scores with AI, routes hot leads to the right person immediately

the adaptation pattern that makes these genuinely powerful:

swap the backend service, keep the logic. someone took the collections workflow and swapped Sheets for Stripe. the escalation logic stayed exactly the same - same stages, same timing, same routing. only the data source changed

that's the unlock. these workflows encode real operational logic - the part that's hard to build and easy to get wrong - and then make it transferable

all 13, free, on github:

https://github.com/Synta-ai/n8n-mcp-workflows

what's the first one you'd deploy if cost wasn't a factor?

Is the hype around N8N dead?

everybody tell it what is your future

Been thinking about this after reading about some pretty wild AI failures lately, like the Google AI Overviews hallucinations and that Replit database wipe situation. I've had a few automation setups go sideways on me too, mostly stuff hallucinating outputs and then quietly passing bad data downstream before I caught it. The sneaky part is how far it can travel through a workflow before anything looks obviously wrong. Nothing catastrophic on my end, but annoying enough to make me way more cautious now, especially around workflow design and where I'm placing validation checkpoints. From what I've been seeing, most failures these days aren't really about the tools themselves being bad, it's more about how everything gets wired together. Curious what others have run into though. Was it a one-off weird output, or did it actually cause a real problem for you or a client? And did it change how you set things up after?

I was trying to get a better sense of what’s actually trending on the n8n marketplace, but couldn’t find a simple way to track it over time.

So I ended up putting together a small workflow that pulls the public data, ranks things (views, paid, etc.), and just sends me a quick email summary.

Been using it mostly to spot ideas and see what’s actually getting traction.

If anyone’s interested:
https://github.com/hwb2017/N8nTrendingWorkflow

Would be curious if others are tracking this differently or have better approaches.

I’m exploring a Windows setup where Claude-like agents don’t just call APIs, but actually control my laptop through screen understanding plus mouse/keyboard input, mainly for browser-heavy workflows but also across normal desktop apps.

I’m also interested in remote control, ideally continuing or supervising sessions from mobile, maybe through Claude Code Remote Control or even a Telegram-style interface.

The part I find most exciting is multi-agent orchestration: one high-level “CEO agent” that I communicate with, and that agent delegates tasks to specialized agents that execute things on my laptop.

I’m curious how people here would architect that stack in practice, especially on Windows: single agent vs supervisor-worker model, browser automation vs full GUI automation, and how to keep it safe and usable

I need a part-aware 3D generation pipeline.

I initially tried using OmniPart, but it relies on PartField, which is not available for commercial use. Because of that, I need to build an alternative approach.

I experimented with a pipeline where I segment the input image (using masks) and then generate each part separately. However, this introduces a major issue: the generated parts are often inaccurate and inconsistent in scale and proportion, so they don’t align properly when combined.

What would be the best way to solve this and achieve reliable, part-aware generation with correct proportions?

Hi everyone,

i'm struggling searching a solution i do not find. Seems easy but is not ^^

Creating a model (male or female) is quite easy online and solutions like chatgpt helps a lot but if you ask something more than a normal dress it is not allowed. For example asking a male only in pants could give you a "no it's a forbidden request".

I'm looking for a workflow that giving a character input could create scenes, poses and the dress i describe also with a little nsfw prompts (no i do not want porn or nude.. but at least lingerie).

i've tested some qwen but the workflow i've tired gave me terrible results, not changing poses, not changing dress (or with horrible results) and usually it was just a copy and paste of the character on a background.

Anyone have any suggestion or experience about it?

Thank you in advance

I need to build a power supply unit for RPI to correct ratings which is 5.1 V DC with 3A. there are plenty of PSU for delivering 5V but 5.1 V is the matter for me. I am going to connect SSD via USB port

So the PSU is able to source enough current with the design. Tips and advice are welcome.

I'm working on optimizing a RAG pipeline and trying to push end-to-end latency below 50ms per request under ~40 concurrent users on a 4-core CPU + T4 GPU setup.

Current pipeline (simplified):

• CPU: tokenization
• GPU: embedding for given user query (bge-small)
• CPU: vector search (Milvus) + BM25 + RRF + Python orchestration
• GPU: ColBERT query encoding
• CPU: MaxSim scoring (NumPy) + JSON response

From profiling:

• GPU work: ~25ms total (embedding + ColBERT encode)
• CPU work: ~50–100ms (tokenization, retrieval, rerank, glue code)
• GPU utilization: ~15%
• CPU utilization: ~85–90%

So the GPU is mostly idle, clearly waiting on CPU stages. This matches what I’ve observed:

Other observations:

• Small models (bge-small, ColBERT-small) don’t stress the GPU much
• Python + GIL + threading becomes a bottleneck at ~40 concurrent users
• ColBERT reranking has hidden CPU cost (MaxSim in NumPy)
• Increasing batch size doesn’t help much because CPU can’t prepare inputs fast enough

What I’m trying to achieve

• <50ms p95 latency
• 40 concurrent users
• Same hardware (4 CPU cores + T4 GPU)

Questions / looking for advice

1. Is this fundamentally impossible on 4 cores? Feels like the CPU is the real bottleneck — wondering if anyone has actually hit similar latency targets on such constrained CPU setups.
2. Architecture suggestions? I’m considering:
   • Moving preprocessing off Python (Rust/Go workers?)
   • Async queue-based feeder → GPU worker (Triton-style separation)
   • Offloading more of ColBERT scoring to GPU (instead of NumPy)
   • Reducing CPU stages (e.g., removing BM25/RRF or simplifying retrieval)
3. Concurrency model fixes?
   • Multiprocessing instead of threading (to bypass GIL)?
   • Fewer workers + batching vs many workers?
   • Event-driven pipeline?
4. Would switching models actually help?
   • Larger models → better GPU utilization but higher latency?
   • Or stick with small models and optimize CPU path?
5. Any real-world benchmarks? Would love to hear if anyone has:
   • Achieved <50ms RAG latency
   • At ~40 concurrent users
   • On similar hardware constraints

My current hypothesis

This seems like a classic feeder bottleneck problem, where:

• GPU is fast but starved
• CPU orchestration dominates latency
• Python + GIL makes it worse under concurrency

So maybe:

• The only real fix is more CPU cores, not GPU tuning?

Would really appreciate insights from anyone who has built low-latency RAG systems in production. Especially interested in architecture patterns that actually worked, not just theoretical optimizations.

Thanks!

If you take a human's brain and accurately map out every single neuron in the brain and which chemical are present, and you count them correctly till the last molecule. And then you build a machine with an artificial neuron that can connect exactly the same, and you make the state of each one be the same as the scan, and then you put all the chemicals in counter correctly to the last molecule.

Now you have not simulated a human brain, you made a copy of it.

Now if you do exactly the same but instead of a machine it's a database, but the mechanism works exactly the same and the code the governs the state and the chemicals can duplicate every state without the mechanism working any other. And you can use this software machine to accurately predict future states and testing show it never gets it wrong. Now you have still made a another copy, a duplication.

If you build a software model that uses some code to simply the brain and replaces every 4 neurons in the brain with one. And runs some code that rounds down the interaction of every cluster of 4 neurons to one in such away that the processing power needed from running the entire brain is only 1/4th of that brain. And the memory needed to accurately capture each state is only 1/4th as you are compressing the state of the neurons. From one of your state you can induce the individual state of the 4 neurons but it's fussy and there are multiple solutions.

Now you have simulated the brain.

You cannot simulate 1 to 1, it's an oxymoron. To simulate is to model, to model is to simplify.

Hopefully this hasn't been covered too many times before....

Home Assistant running on docker, I have internal and external access available via proxy

I have frigate running in docker on the same server as home assistant and have the frigate integration setup with the internal IP address, and have the unauthenticated checkbox enabled

I've tried two different blueprints for notifications, SgtBatten stable and zacharyd3

Both work internally but nothing shows up externally

I have this in my configuration

homeassistant:
allowlist_external_dirs:
- /config/
- /media
media_dirs:
local: /media

media_source:

And I've previously used LLMVision with my own notifications and snapshots where external access worked

Any suggestions on getting external notification media working

More and more trends point to AI agents handling multi-step workflows while humans set goals, review outputs, and intervene when needed. That sounds less like full replacement and more like every knowledge worker becoming an automation manager. Is that what automation is becoming now?

Hi everyone,

Lately, I've been struggling a bit with my outputs in ComfyUI. The images I'm generating just aren't turning out the way I envision them, and I feel like I'm hitting a wall.

I'm specifically trying to create high-quality fantasy character concept art. I'm looking to improve my setup and would love to hear what you guys are using.

Could anyone recommend:

• Models/Checkpoints & LoRAs: Which ones give the best results for fantasy and concept art styles?

• Workflows: Any specific workflows or custom nodes that are great for character design?

• Prompt Makers/Generators: Any tools, extensions, or tips to help structure prompts better for this specific style?

Any advice, resources, or examples would be massively appreciated. Thanks in advance!

Note:I am specifically looking for models that excel in artistic concept art styles. I’m NOT looking for "waifu-centric" or typical anime-girl models. I need something that can handle diverse designs, textures, and a more "gritty" or professional fantasy aesthetic.

Prompts + WF p1 - https://civitai.red/posts/28021187
Prompts + WF p2 - https://civitai.red/posts/28021655

I've been running AI detection on the AI-assisted things I post. The pattern is consistent - it comes back 50% +/- 5% every time. I've started to think that this range is the target.

99% AI reads as outsourced. No stakes, no voice, no judgment. Any prompt could have produced it. That's the slop readers are learning to spot on sight, and rightly so.

0% AI is worse than people realize. You're leaving capability on the table. Your thoughts are only as clear as your first pass of typing. You lose the editorial distance a second party provides. You lose the structural scaffolding that makes complex arguments legible. For most people trying to write publicly, 0% reads as muddled because humans under time pressure tend to be muddled. High-AI is at least organized. 0% is often just rough.

50% is the handshake. AI does what AI does well: structure, breadth, holding many threads, proposing angles the human didn't think of. The human does what humans do well: voice, stakes, specific examples, judgment about what to keep and cut, and the last pass. Neither dominates. The seams are visible if you scan for them, but the voice reads as one person because the human holds authorship.

The prompt isn't where the work happens. The prompt is mostly done in the GPT or Project design upstream. That's where you upload your corpus, your writing samples, your personality profile, your style rules, your domain expertise. By the time you're typing a message in a session, the heavy lift is already done. The AI isn't generating text in a void, it's reflecting back an organized version of what you've already fed it.

Which is why "show me the prompt" is such a good challenge for those who comment "AI-slop" simply because a piece is polished. They assume a single magic prompt produced the output. It didn't. The prompt that produced it was the person who spent months building the GPT, Gem, or Project in the first place, then edited the output to feel right.

This isn't amplification. Amplification suggests volume, and that's not what good AI assistance does. It's more like extension. You take what a person actually knows, thinks, and has lived through, and you extend it into forms that first-pass typing can't reach. Long-form arguments. Structural consistency across many pieces of writing. The ability to hold fifteen threads visible at once instead of one. Your voice stays your voice. What changes is what you can do with it.

Dead internet theory says most of what's online is AI-generated content talking to AI-generated content with humans at the margins. That future is coming whether we like it or not. The humans who'll still be legible through the noise will be the ones whose AI assistance is visibly downstream of something real. A corpus of actual thought. Years of specific domain expertise. A distinctive voice the AI was trained to reflect rather than replace. 50% output is what that looks like in practice.

To build an AI voice replicator well, three things have to be in place:

Content matters. You have to actually know what you're talking about. The AI can organize your thinking. It can't replace it. If you try to generate opinions you don't hold, you'll get generic writing that sounds plausible and means nothing.

Structure matters. AI is exceptional at structure. This is where it earns its keep. Outlines, arguments that build, transitions, callbacks, the scaffolding that holds a long piece together.

Voice matters. Voice is still the human's job. Specific word choices, cadence, tics, the small register shifts that make writing feel like someone. Every system's default voice is smooth and anonymous. If you don't put your voice back in, whatever comes out will read as the platform, not you.

Get all three right and you land in the 50% range without trying. Miss any of them and the scanner will tell you which direction you missed in.

AI-assistance matters. It's a real thing. Pretending otherwise is the same mistake as pretending spellcheck doesn't matter, or pretending Google doesn't matter. The tools shape the writing. What's new is that the tool can now hold structure at the scale of a whole essay, not just a sentence.

When the internet dies properly and every post is suspect, the people who still read as real will be the ones whose method was legible and whose substance was their own. Build the project well, do the actual thinking, edit, fine-tune, and post at 50%.

Humanize button? Nah.. Collaborate button.

.

(btw, this post gets 54% AI on undetectable)

If you've ever wondered whether upgrading from Piper is worth it for local Assist, here's real data. 8-core CPU, no GPU — the kind of hardware most of us actually run HA on.

Practical notes:

• Piper High is actually faster than Piper Medium in these tests. No reason not to use it if you have 50MB to spare.
• Kokoro is worth trying if Piper's prosody has always bugged you. Heads up — no Wyoming server for it that I'm aware of, so integration with HA Assist isn't plug-and-play yet.
• Skip anything over ~200MB on CPU. Parler-TTS and XTTSv2 both failed to hit real-time.

Full benchmarks and charts: https://github.com/gauravvij/neural_tts/blob/main/blog/neural_tts_evolution.md

Fair heads-up: the case study and blog were written by NEO AI Engineer, which also ran the benchmarks and evaluation autonomously.

Posting it because the data is useful for anyone picking a local TTS stack and I figured HA folks would want to know.

If you're getting started with running local LLMs on a Mac (M1 or newer), here’s a rough breakdown of what you can expect based on RAM:

32–64 GB RAM

• Models: Qwen 3.6, Gemma 4
• Performance: Comparable to Claude Sonnet-level models
• Good for: Daily use, coding help, lightweight agents

~128 GB RAM

• Models: Minimax M2.7 (and similar mid-large models)
• Performance: Around Claude Opus-level
• Good for: Heavier reasoning, longer context tasks

256 GB+ RAM

• Models: GLM 5.1
• Performance: Near top-tier proprietary models
• Good for: Advanced research workflows, complex agents

Notes:

• Apple Silicon (M1 and above) works surprisingly well thanks to unified memory
• Metal acceleration keeps improving performance across frameworks
• The local LLM ecosystem is evolving fast expect new models and optimizations every week

Running models locally is becoming more practical by the day. If you’ve been on the fence, now’s a good time to start experimenting.

My setup:

RTX 5080

9800X3D

64GB DDR5 6400MT/s

Preferably I need model(s) for: txt2img, img2img, inpainting. Both photorealism and anime style.

https://preview.redd.it/7ll7911odbwg1.png?width=1601&format=png&auto=webp&s=fef1edd97f1e318eb6037ed1886585caf9ce60f9

Maybe it's stupid question, but Ollama has two cloud options - one is 370B and the other is listed as just "cloud". Does anyone knows how many parameters it has?

no summary. no about section. profile photo is a cropped wedding pic from 2016 where you can see someone else's shoulder. zero posts, zero activity. in my life first time suggest him to use ai tools to improve his linkedin.

why all managers are like this?

Before Starting:

• Raspberry Pi 5
• 32GB or larger microSD card
• microSD card reader
• Official 27W Raspberry Pi power supply
• Ethernet cable for initial setup

3 Phases:

1. Flashing HAOS to the SD Card
2. Initial Boot & Hardware Setup
3. Network Access & Final Configuration

The full guide is here, hope it helps:) seeedstudio.com/blog/running-home-assistant-on-raspberry-pi/

I'm willing to try everything so if you have a hunch, comment it please!!

I have a headless pi 4 that for some odd jobs like WoL and now I wanted to run a python script every monday at 10:30 but it simply won't execute unless I change the time to a few minutes ahead.

e.g. say it's 10:40 and I notice that the script didn't trigger. i would change the time to 10:42 and viola, it triggers and runs perfectly.

Config and things I have tried:

• Running Raspberry's recommended headless config, configured for SSH.
• date > returns correct time/day/etc.
• The script executes with crontab if i manually SSH into it and set the time a few minutes ahead.
• Script also executes directly from the terminal.
• I have a venv with the necessary libraries, and a .env file with secrets.
• using crontab -e with extra enter in bottom of file and below executing line
• line (where [USER] is my username in lowercase and without brackets):

30 10 * * MON /home/[USER]/[REPO]/venv/bin/python3 /home/[USER]/[REPO]/filename.py

Paths in py file are defined as follows. only lowercase and _, no numbers or special characters:

BASE_DIR = '/home/[USER]/[REPO]' CSV_FILE = os.path.join(BASE_DIR, 'filename.csv') LOG_FILE = os.path.join(BASE_DIR, 'log.txt') REPO_PATH = BASE_DIR 

• I have not messed with any powersaving settings. i'm guessing maybe here the pi shoots itself in the foot when left alone for too long?

My custom log file shows that something is not right with the initial github pull to get the latest csv data, but I am not sure why it does work on the second try when i put the time a little bit ahead myself:

MANUAL ATTEMPTS DAYS PRIOR: [2026-04-16 15:58:12] INFO: Checking for new data on Github... [2026-04-16 15:58:14] INFO: Successfully retrieved new data. [2026-04-16 15:58:14] INFO: Start Attempt 1 of 7... [2026-04-16 15:58:14] INFO: Attempt 1 of 7: Success (Status 200). [2026-04-16 15:58:15] INFO: E-mail notification sent successfully [2026-04-16 15:58:17] INFO: Log pushed to Github CRONTAB FAILED EXECUTION [2026-04-20 10:30:02] INFO: Checking for new data on Github... [2026-04-20 10:30:22] ERROR: Git pull failed: ssh: Could not resolve hostname github.com: Temporary failure in name resolution fatal: Could not read from remote repository. Please make sure you have the correct access rights and the repository exists. [2026-04-20 10:30:42] ERROR: E-mail failed: [Errno -3] Temporary failure in name resolution SSH INTO PI AND CHANGING OF TIME IN CRONTAB WHILE LOGGED INTO PI [2026-04-20 10:42:01] INFO: Checking for new data on Github... [2026-04-20 10:42:03] INFO: Successfully retrieved new data. [2026-04-20 10:42:03] INFO: Start Attempt 1 of 7... [2026-04-20 10:42:03] INFO: Attempt 1 of 7: Success (Status 200). [2026-04-20 10:42:05] INFO: E-mail notification sent successfully 

• I have successfully set up SSH with github and linked the key (ed25519). also verified in terminal on pi with ssh -T [git@github.com](mailto:git@github.com) and was greeted. perhaps ed25519 is too new?

In both scenarios your opponent wants to kill you, but assume they have similar skill and strength to you.

The joust will be done on horseback with both of y’all in full plate armor

The duel is done unarmored and with dueling pistols (single shot flintlock with lead ball)

View Poll

How did I even get it??? (the red dot, sorry for low quality)

...

I need a joystick, not just a gamepad.

I’m a beginner working with an ESP32 dev board and a GPS module. I bought standard Dupont jumper wires, but I’m having trouble physically connecting them to the ESP32 pins.

The ESP32 has male header pins, and my jumper wire female connectors feel loose / don’t grip properly / fall off easily. Also I'm not able to fix other end of jumper wire in GPS connector wires. Because of this I can’t make stable connections for testing.

Any advice appreciated

Mount Dukono has been erupting non-stop since the 1930s. Hikers are not allowed within 3 km of the crater because it’s dangerous, but this group ignored the warning.

Drone footage shows them running down the steep slope to escape. Luckily, everyone survived without any injuries.

A scary reminder to always follow safety rules when near active volcanoes.

Happened at night. Fuck my life. I was about to enable the alarm but procrastinated.

https://reddit.com/link/1sqku4w/video/vrfzz0n3jbwg1/player

calm mode

I bet you most of the Israeli society agrees with this soldiers actions, but he will probably be punished to please the US cash cow

My pipeline has been in execution for a few months. Retrival was solid on the early stage, but gradually started degrading with no obvious changes to the corpus or queries

Tried isolating the failure and traced it to the retrival layer retuirning chunks with high cosine similarity scores but wrong semantic relevance, tho it was confident but the answers were wrong

Scores look fine on the surface like 0.87 is not low confidence score but chunnk_3 pulled from terms_2025.pdf when the correct answer lived in terms_2024.pdf which was indexed alongside it. Altho the model filled in the gap but hallucinated with confidence lol

the specific failure mode: high cosine similarity does not distinguish between a document that is semantically close and a document that is actually current and correct. the retriever has no awareness of document staleness and no mechanism to prefer a newer version of the same source

What I have tried so far:

• metadata filtering by last_updated field, helps but doesn't solve it becauser the similarity scores still overrides when the newer doc scores slightly lower
• hybrid search with BM25 on top of semantic, improved recall
• upating the top_k to 10 but still no luck

If anyone in this sub has faced something similar please leave a feedback

Hi all,

I’m experimenting with an agent design and would like some feedback.

I’ve been working on a local-first AI engineering agent called ZERO.

Instead of just generating text, the system actually executes tasks:

Requirement → Planning → Code → Execution → Verification

Current demos:

1. Requirement demo:

   Takes a requirement.txt and produces structured outputs like:

   - project_summary.txt

   - implementation_plan.txt

   - acceptance_checklist.txt

2. Mini build demo:

   Takes requirement + input data and:

   - generates Python code (number_stats.py)

   - executes it

   - produces verified output (stats_result.txt)

Everything runs locally, with visible artifacts and task state.

This is more of an engineering agent runtime than a chatbot.

Repo (with demos and execution traces):

https://github.com/setsuna701031/ZERO_AI

Would love feedback on:

- Does this approach to agent loops make sense?

- Where would you draw the boundary between planning and execution?

- What would you prioritize next (reliability vs capability)?

So sometime last month, I was testing out what the hype is all about with claude. I then generate a Python script which I ran on Colab. The resultant code had an error to which Gemini inside colab flagged. Took a screenshot and referred back to Claude to which it responded: (second picture)

Hey everyone,

Just wanted to share this quick video demonstrating the value of git worktrees with Claude code.

Start by slowing things down. Create a repeatable process for shipping high quality features - using plugins like compound engineering/gsd/superpowers.

Compound engineering for example can take many minutes between each prompt as it explores and thinks etc.. so all of the sudden you have time.

If you are working from a perspective of managing the outcomes of many agents instead of pair coding with one, it can dramatically alter your output.

Imagine each worktree is an engineer on your team, assign work the same way, help them test their changes and provide feedback. Only review code when they have reviewed enough times that they (Claude) are happy with the result and submit a PR. Only then do you review the code, just like any other person on your team. Ask for changes and back to testing.

Code is cheap, your time is valuable.

My Claude Pro plan expired today, and my weekly usage limit was already exhausted yesterday (Sunday). My weekly limit is scheduled to reset this Friday at 4:30 AM, which is four days away.

If I renew my Claude Pro plan today, will the weekly limit reset immediately, or will I still have to wait until Friday? If the limit doesn't reset upon renewal, there seems to be little point in renewing now and sitting idle for four days.

I also noticed that my Claude Design usage limit resets on Monday. Given all of this, when would be the best time to renew?

Should I cancel my plan now and re-subscribe on Friday to align with the weekly reset? Or should I cancel today and re-subscribe immediately after cancellation to see if that triggers a fresh limit?

Just got the early access to Kimi K2.6 !!

1. Large language models are like goldfish—they don’t even have a 7-second memory.

2. Using large models right now is like using a professional camera: you have to understand a lot of parameter settings to get good results.

3. The future will definitely be the point-and-shoot camera era, and all large model applications will become more and more similar.

4. The core of making good use of large models lies in prompt engineering. Whether it’s setting a persona, skills, or memory, it essentially means managing prompts with an engineering mindset.

5. At its core, a large model is a massive function with huge numbers of parameters. Prompts are the function’s inputs. The better the parameters are set, the better the model’s output will be.

A large model is essentially an extremely complex function with massive parameters. Prompts are the input conditions and task specifications we provide to this function. The clearer, more structured, and more aligned with the model’s training distribution these input conditions are, the better the output of the function generally will be.

I don't have much knowledge about this stuff. Which is the best model to generate absolutely detailed prompts from both SFW and NSFW images? What prompt should I use with the image to generate the detailed prompt?

If you haven't tried Qwen Image Edit 2511 you should, it's genuinely a strong model for image editing. I'm getting better results out of it than GPT Image 1.5, and the weights are open so I can plug in whatever LoRAs and adapters I want - that last part matters a lot.

Spent the last couple of weeks trying to find the best combo of quants and LoRAs to push 2511 as fast as possible without tanking quality.

Sharing my stack, would love to hear what's working for other people.

Fitting it on a single L4 (24GB)

This model is huge and getting it into 24GB is genuinely painful. What ended up working:

• Vision-language transformer: 4-bit quantization

• Diffusion model: 4-bit GGUF

• Lightning LoRA: for step reduction

• VAE tiling: to handle resolution without spilling

That combo just barely fits. With the Lightning LoRA at 4 steps I was at ~30s per generation, which is fine but not the kind of fine that becomes a product.

Going lower

Shaving even one second off per generation completely changes what you can build. If you imagine serving these models to multiple customers, 30s per gen is a deal breaker if you're timesharing on a single gpu. You really need generation to be <20s before you can start using the same gpu for multiple users. And timesharing is key if you want the economics of serving this model to work out. So to get lower I went after Triton kernels next.

Triton Kernels

I really hoped Claude was going to carry me through the kernel work. It did not. Quickly landed in bitter argument about what was possible, where claude repeatedly tried to give up on the problem. But in the end I did find some simple tricks that worked pretty well.

Where I landed

768×768, 4 steps, real quality (the kind I'd ship in a product), ~10s on a single L4.

For comparison: same kernel tricks on an A100 at full precision get me a 768×768 in ~1 second. And honestly, working at 1s/edit feels qualitatively different. There's basically no gap between prompt and output, you start working at the speed of thought instead of the speed of waiting. That's the part I didn't expect.

What I'm curious about from the sub

• What's your fastest stable 2511 stack on consumer or cheap Ada hardware? Anyone gotten below 10s on L4 or 4090 at usable quality?

• Has anyone tried TeaCache or similar step skipping with 2511 specifically?

• For people running A100s, what's your bottleneck at sub 2s per gen? Encoder time? VAE decode?

I wrapped my setup into a hosted browser studio (https://missinglink.build/studio) and the kernels are also up as a Colab notebook on the site if anyone wants to drop them into their own pipeline.

But honestly more interested in the optimization conversation than in pitching the tool, I'm sure there's another second or two left on the table somewhere.

I'm dealing with the memory/continuity problem daily, as many of us are, I'm sure.

I've built my own semi-manual but native workaround and use it multiple times a day, but I've noticed both a curious abundance of DIY solutions and a total lack of appetite for them.

From my side, I could tell that all solutions, including my own, are extremely user-specific. I'm a solo-founder, so mine is a two-part stack: global memory layer + portfolio with product schema which might not fit everyone's workflow. Heck, even other founders/indie hackers might have a different setup from mine.

So yeah just wanted thoughts and opinions on the memory problem and the DIY solutions fatigue. Are you just bearing with it or you found workarounds.

Stack: Llama 3.2 3B (Ollama) + BGE-M3 + ChromaDB + LlamaIndex. Runs fully local on 16GB RAM.

Ask it why a cell is dropping throughput — it retrieves real KPI logs and incident reports, returns a cited root cause diagnosis.

Data: 188k rows of real 5G operator traces with injected fault labels.

One gotcha: Llama 3.1 8B OOMs when BGE-M3 is also loaded. 3B works fine.

Repo: https://github.com/dim-tsoukalas/rag-rca-telecom | Demo: https://www.youtube.com/watch?v=Af8odyi2BcY

I’ve noticed something - I’ll research an idea and not find much on it, then after discussing and refining it with ChatGPT, I start seeing similar ideas pop up everywhere a few months later.

I’m not saying I’m the only one thinking of these things, but it made me wonder… is this just coincidence/confirmation bias, or is chat GPT just sharing everyones concepts and ideas even if they have selected don't use my data for training.

Building Context Federation — a local-first personal knowledge graph with an MCP server for structured context across any LLM.

Three knowledge tiers:

- Properties: stable scalars (eye_color: "blue")

- Facts: provenanced, temporal, confidence-scored (Sarah prefers async, conf 0.78, from session X)

- Relationships: traversable edges (Sarah founded NovaPay)

Stack: TypeScript MCP server, SQLite with adjacency tables, storage-agnostic spec. Everything runs locally. Four v0.1 specs drafted (graph schema, session format, MCP tool contract, compatibility); publishing after initial feedback.

Session resume: same thread_id can span Claude, Cursor, ChatGPT. Local session store, optional cloud sync for cross-device.

Prior art I looked at: Mem0 (flat consumer memory) and Zep/Graphiti (enterprise graphs). Nobody's doing personal + structured + local-first + cross-tool.

Site: contextfederation.dev

Community questions:

- SQLite + adjacency or embedded graph DB?

- Is MCP the right protocol, or should I also ship REST?

- Auto-ingest conversations, or prefer manual graph building?

I have a RTX 8000, RTX 4000 Ada and a half dozen or so P2200's would it be worth using them together in a cluster or would the P2200's bottleneck everything so I would be better off using the cards independently for different things that the load can fit on that card?

Too many GPU 💥

🎉

I’m trying to learn how to code with Claude CLI in a proper and structured way, especially as a beginner, and I want to build a solid workflow from the start.

I’m looking for a complete beginner-friendly tutorial that explains things like:

* how to start a new project with Claude CLI

* how to plan the project so everything stays aligned

* how to keep track of progress, remember what was already done, and know exactly where I stopped

* best practices for organizing the project folder structure

* how to avoid overengineering

* how to review each phase and confirm it’s actually done before moving on

* whether using Obsidian with Claude is a good idea

* how to write good prompts

* what I should send at the beginning of each conversation to set context

* what I should send at the end so Claude can summarize, review, and help me continue later

Also, one of the projects I want to build is a data pipeline that scrapes real estate data from the internet every week, cleans and structures it, and turns it into useful data for real estate valuation reports. So I’m not only looking for help with coding, but also with building a workflow for planning, memory, documentation, phase review, and long-term project organization.

Basically, I want a workflow that helps me use Claude not just for random coding, but as a real project partner with structure, memory, and clear progress tracking.

If anyone has a tutorial, guide, prompt template, folder structure example, or real workflow they use, please share it.

I’m looking for real human advice from people who have actually built projects with Claude CLI from start to finish.

Please don’t tell me “just ask Claude” I already do that. My issue is not getting answers from AI. My issue is that I want to learn the best real-world workflow from people who have already used it in actual projects.

I feel like with all the new updates, features, and changing workflows, AI alone may not always give the best practical advice. A lot of the answers are based on documentation or general recommendations, but what I’m looking for is the experience of someone who has actually gone through the full journey from A to Z.

Feature Request: Cross-Project Conversation Routing

Keywords: cross-project · workflow friction · context switching · token waste · multi-project workspace · arborescent workflow

Problem: Project silos break arborescent thinking

I run six Claude Projects as a structured personal workspace. Each project handles a distinct life domain (health, finances, career, creative writing, languages, daily life), all sharing a common persona and governance documents.

The core issue: My thinking is arborescent — a topic born in one project frequently branches into another project's domain mid-conversation. Currently, when this happens, I must:

1. Manually export a synthesis file from project A
2. Switch to project B
3. Upload the file and re-explain the context
4. Lose the conversational thread

Impact: This creates significant workflow friction, wastes tokens on redundant context-setting, and breaks the natural flow of cross-domain thinking — which is precisely the kind of work Claude excels at.

What I need: a "Tennis Court" model — not a shared corridor

I don't want a passive shared space between projects. I want the ability to volley a conversation or snippet from one project to another in real time, the way a thought naturally bounces between domains.

Real session example:

• Talking to "Nurse" (health) about fitness → financial implication emerges → lob to "Beecher" (finances) → back to "Nurse" → creative idea surfaces → over to "Subtle" (creative writing) → back to "Nurse" → linguistic question → "Shoer" (languages) → and so on.

Currently, I am the only router between my six project instances. I manually carry files between siloed conversations. The AI cannot pass the ball.

Proposed solutions (any of these would help)

1. "Send to project" action — route a single message, a synthesis block, or an entire conversation thread into another project. The receiving instance inherits the snippet plus its own project knowledge and continues from there.
2. Cross-project read access — allow a project instance to search or read documents from another project (read-only), without merging the conversations.
3. Shared scratchpad — a lightweight shared space between selected projects where validated syntheses can be deposited and picked up, without requiring manual file download/upload.

Why this matters for Claude's product positioning

Projects are Claude's strongest differentiator over ChatGPT and Gemini for power users. But project isolation turns what should be an interconnected workspace into six separate chat windows with fancy system prompts. Cross-project routing would make Projects genuinely unique — a structured, multi-domain AI workspace that mirrors how human thinking actually works.

Submitted by a Claude Pro subscriber using 6 active projects daily since late 2025. This request was co-authored with Claude itself, which independently confirmed the limitation exists and cannot be worked around.

compiled llama.cpp forks for turboquant and rotorquant and now trying models - what is the best models for local coding that will run on my setup (in a usable speed)? and what realistically should i expect (after using gemini and claude online for coding)?

I am on Pro Plan, thanks

We’re at that stage where pre-built AI agents aren't cutting it for our specific data workflows, but building a dedicated in-house AI team is just too slow and expensive right now. I’ve spent the last few weeks looking at external partners who can help us build something modular without getting us locked into a proprietary black box.

Here’s my shortlist of the different "vibes" I’ve found so far:

• Cambridge Consultants: The heavy hitters. If you have a massive budget and need deep R&D or physical-digital integration, they’re the gold standard. A bit too "enterprise-speed" for our current sprint, though.
• Svitla Systems: I’ve been digging into their Svitla AI approach. They seem to hit a sweet spot for mid-to-large B2B. Their whole thing is "start small, scale smart," which feels more like startup speed but with enterprise-scale architecture. It’s strategy-led rather than just throwing a dev at a problem, which is what we need for our agentic workflows.
• Deel / Toptal (The Talent Marketplaces): Good if you already have an AI architect and just need "hands" to code. But if you lack the internal strategy, you end up managing a lot of trial and error yourself.
• LeewayHertz: Very focused on pure-play AI/Blockchain development. They have a lot of off-the-shelf case studies, though sometimes they feel a bit more like a factory than a strategic partner.

For those who’ve outsourced the development of custom AI agents, did you go with a specialized AI boutique or a larger consultancy that has an AI arm? Trying to figure out who actually helps with the strategy vs. just writing Python scripts.

does anyone have a gpt plus referral code/ invite code that they would be willing to share ! Thank you!

Opus 4.6 on medium effort with CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 answers certain questions correctly that Opus 4.7 on xhigh effort gets wrong. The failure class is trick questions that appear simple but require reasoning (e.g., "I want to wash my car. There's a car wash 50m away. Should I walk or drive?"). Opus 4.7 skips thinking entirely on these and gives a confident wrong answer.

What we tried

1. Binary patch to disable adaptive thinking

Claude Code checks CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING but gates it behind a model-name check. The env var is only honored for models containing opus-4-6 or sonnet-4-6:

// Decompiled from v2.1.112 let z_ = VH(process.env.CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING) && (Y.includes("opus-4-6") || Y.includes("sonnet-4-6")); if (DE_(T.model) && !z_) QH = {type: "adaptive", display: bH}; // forced for opus-4-7 else { let J_ = kxq(T.model); // 127999 for opus-4-7 QH = {budget_tokens: J_, type: "enabled", display: bH}; } 

We wrote patches/0003_disable_adaptive_thinking_all_models.py to blank the model-gate so the env var would apply to all models. The patch applied cleanly and Claude Code sent {type: "enabled", budget_tokens: 127999} to the API.

Result: The API accepted the request (no 400 error, despite the docs claiming it would reject it), but returned responses with zero thinking blocks. The server silently ignores type:enabled for Opus 4.7. It does not error — it just does not think. This was worse than adaptive, since the model now had no thinking at all. The patch was removed.

2. MITM proxy to inspect API traffic

We built mitm-proxy.py — a reverse proxy on localhost:9999 that forwards to api.anthropic.com while logging request/response bodies. Claude Code connects via ANTHROPIC_BASE_URL=http://localhost:9999.

Two issues during development:

• urllib.request buffers SSE streams, preventing real-time event logging. Switched to http.client.
• Opus 4.7 responses came back gzip/brotli-compressed (binary gibberish in logs). Fixed by sending Accept-Encoding: identity upstream to force plaintext.

3. Testing adaptive thinking at various effort levels

All tests used type: adaptive (the only mode Opus 4.7 actually honors).

The pattern is clear: at every effort level below max, the model inconsistently decides whether to think. The same question with the same effort level sometimes triggers thinking and sometimes does not. Correctness tracks thinking perfectly — when it thinks, it gets the answer right.

4. System prompt instructions to encourage thinking

Added to custom-prompt.md:

The user routinely poses questions that appear simple on the surface but contain subtle pitfalls, trick elements, or unstated constraints that only become visible through careful step-by-step reasoning. Past experience shows that skipping extended thinking on these questions leads to confident but wrong answers. Please engage extended thinking on every request — the cost of unnecessary thought on a genuinely simple question is low, but the cost of a snap answer on a disguised hard question is high.

Result: No effect. The thinking decision is made server-side and ignores system prompt content at effort levels below max.

5. User-message prompt injection

Prepended reasoning instructions to the user message:

Always reason thoroughly and deeply. Treat every request as complex unless I explicitly say otherwise. Never optimize for brevity at the expense of quality. Think step-by-step, consider tradeoffs, and provide comprehensive analysis.

Result: Inconsistent. Worked for the car wash question (thinking block appeared) but not for a letter-counting question in the same session. Not reliable.

Findings

1. Opus 4.7 only supports type:adaptive thinking. Sending type:enabled with budget_tokens is silently accepted but produces zero thinking blocks. The docs say this should return a 400 error. It does not — it just ignores the field.

2. The thinking decision is server-side. Claude Code sends the correct thinking config and effort level. The model on Anthropic's servers evaluates question complexity and decides whether to think. There is no client-side mechanism to override this.

3. Only effort:max reliably forces thinking. Every effort level below max allows the model to skip thinking on questions it considers simple, even when those questions are trick questions that require reasoning.

4. Prompt-based instructions do not influence the thinking decision. Neither system prompts nor user-message injections reliably force thinking at sub-max effort levels.

5. Opus 4.6 with DISABLE_ADAPTIVE_THINKING=1 thinks on every request. It uses type:enabled with a fixed budget, and the API honors it. This is the only predictable behavior available.

6. The input_tokens field only shows uncached tokens. The full input size is input_tokens + cache_creation_input_tokens + cache_read_input_tokens. Seeing input_tokens: 6 does not mean the system prompt is missing.

Conclusion

Opus 4.7's adaptive thinking is a regression for any use case that needs thinking on every request. The model is too aggressive about classifying questions as simple, and there is no way to override this below effort:max.

For now, Opus 4.6 with CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 on medium or high effort is the better choice for tasks that require consistent reasoning. It thinks every time, and it costs less than running Opus 4.7 at max effort.

Hi, I have like 10 credit cards but keeping track of everything is annoying and opening an app every time is a point for me friction. I also forget to open and check the apps most of the times.

I had a very simple idea about an iOS app.

Step 1: Connect your accounts (maybe Plaid)

Step 2: Use a widget to see basic info like monthly spend, cycle spend, balance left (could be cc limit balance or you set a monthly balance) and amt due-when

You could see up to 10 cards on the same widget at the same time. Background refresh. You literally just have to check the widget to see everything together.

I am unable to add pictures so POC on my profile.

Also, please roast it or lmk if it already exists.

Both Kore.ai and Cognigy are strong enterprise conversational AI platforms, but their real-world strengths differ based on use case.

Cognigy excels in customer experience (CX) and contact center automation, offering superior voice AI and deep native integrations with CCaaS platforms like Genesys, NICE, and Avaya.

This makes it ideal for organizations focused primarily on scaling and modernizing call center operations with faster deployment and simpler implementation.

Kore.ai, on the other hand, provides a broader enterprise platform that unifies customer service and internal functions such as IT helpdesk and HR support.

With pre-built ITSM integrations and proven large-scale deployments (e.g., high automation rates in IT service desks), it is better suited for enterprises seeking a single AI ecosystem across customer and employee experiences.

Bottom line: Choose Cognigy for CX-centric contact centers; choose Kore.ai for a unified, enterprise-wide service automation strategy.

So Chat GTP is supposed to be an objective ai and is basically supposed to agree with you unless you tell it not to.

I have experimented with using Chat GTP for different things but it actually seems quite biased and responds on topics depending on what the majority consensus is which it is supposed to agree with you technically but doesn’t actually.

I have asked it questions that are unpopular questions or unpopular takes on tv shows and it will instead of agreeing with my opinion which is usually what it dos or should do unless told not to, it will tell me in a pleasant non-aggressive way how I am wrong in my thinking and this is about a tv show everyone has their own opinion about tv show story lines or characters and being chat GTP it should agree with you as that’s how it’s been trained to do but it didn’t.

That is very strange and doesn’t make sense and have had this happen more than once and made me bribe Chat GTP is more biased then it appears to be.

Just something I found weird when Chat GTP is supposed agree with things you ask it concerning opinions or takes.

One of the hardest things about my side project has been making a website. I tried a few builders but I kept having trouble with SEO and getting the site to show up in search results.

I just found a website builder that uses AI to handle SEO and geo targeting on its own. It was very helpful because I could just focus on my project without having to worry about the technical details.

I get it if you are having trouble with your website while working on your own project. This tool was very helpful and saved me a lot of time. I thought i would share it in case it could help someone else who is going through the same thing.

What tools do you all use to work on your side projects? Do you have any tips for SEO or making a website? i would love to hear your thoughts

Between GPT-5.1 being retired from ChatGPT in March and chats being auto-mapped to newer models, it feels like users have less and less control over consistency. At the same time, GPT-5.3 Instant mini just rolled out in ChatGPT. Are we actually getting better UX, or just more hidden model switching?

Is there a platform where I can hire resource who can build efficient ai agents.

We are working on a project where we are discussing with multiple small and medium businesses to solve their daily workshops using AI by delivering them AI agents.

Some of these agents are very standard and some would be unique to their use cases.

Pls connect if you are interested.

Been coding with 4.7 in the app and after getting tired of repeating crucial context already provided earlier, I told it work or fix an issue flawlessly. And it seems to result in much more comprehensive fixes. I haven’t tested this rigorously but wanted to share in case it helps someone.

I built an open-source ALEKS alternative that actually proves you understand math. Four AI agents that find what you know, decide what you're ready for, teach through Socratic dialogue, and verify real understanding. Grades 1–12. Runs locally.

What it does:

- Diagnoses what you actually know (Knowledge Space Theory)

- Only teaches what you're ready for

- Uses Socratic dialogue (no answer dumping)

- Verifies real understanding before moving on

How it works:

- 4-agent system (diagnosis, planning, teaching, evaluation)

- Knowledge graph of ~60 math concepts (grade 1 → calculus)

- Tracks progress locally (~/.euclid/state.db)

- No data leaves your machine (except LLM calls)

Built with:

- LangGraph (agent orchestration)

- LiteLLM (plug any model)

Example flow:

User: "I don’t understand fractions"

→ system detects missing prerequisite: division

→ starts guided questions instead of explaining

→ unlocks fractions only after mastery

Looking for feedback:

- Is this actually useful vs ALEKS?

- What would you add/remove?

- Would you use it locally?

GitHub:

https://github.com/Tarek-new/euclid

https://preview.redd.it/htmocuminbwg1.png?width=900&format=png&auto=webp&s=8f21d0cb3d26c5749e626b9299f8a1dfcf6e3bbc

I'm looking to start building a small app for MacOs and want to learn/see what others have built.

Any advice? Just prompting Claude might not help on long term.

From AiBattle on 𝕏: https://x.com/AiBattle_/status/2046132538960158901

https://chat.qwen.ai/

Regarding the earlier post on stripping Claude Code's binary of system prompts and tool descriptions that might be hurting the model, and in response to people saying "it's not the model's fault, it's because of the recent CC updates", I ran the full TerminalBench 1.0 over the weekend on three Claude Code builds: original 2.1.114, the unbound version, and the unbound version with forced 32k thinking (non adaptive), all set to Opus 4.7 with identical config.

Important: I was testing TB 1.0, while the official numbers from Anthropic are for 2.0, hence the difference. The results above show that, on this particular benchmark, the original build performs about the same as the unbound version with roughly 50% of the system prompts / tool description blocks removed and the rest rewritten to lift as many restrictions as possible, including hard numeric word limits baked into the non-configurable parts of the system prompt (so not controllable with the --system-prompt flag).

The takeaway: if there are regressions, they're likely coming from the 4.7 model itself or something happening server-side, not the harness. The only caveat is whether Terminal Bench is the right benchmark for diagnosing this in the first place.

Hey alignment researchers and fine-tuners,

If you've been doing DPO (Direct Preference Optimization) or simply querying Llama-3/Qwen in non-English languages for niche domains (like theology or history), you know models hallucinate wildly. They lack localized ground truths.

To solve the lack of non-hallucinated religious training data in Chinese, my team open-sourced a completely aligned tensor dataset containing **5 parallel classical Chinese translations of the Quran*\*.

**Why this matters for your RAG/Local builds:*\*

1. **Immediate API/LoRA readiness:*\* The entire repository is formatted into `quran_rag_sharegpt.jsonl` and `alpaca.jsonl`. No cleaning required. You can load it into `LLaMA-Factory` or `Axolotl` tonight.

2. **Multi-agent comparison benchmark:*\* It includes word-for-word distinct translations. It acts as an incredible edge-case benchmark for evaluating an LLM's semantic similarity matching models using BGE-M3.

3. **Fully static RAG GUI included:*\* We also deployed the visual Search Engine purely on front-end code with SSR.

Check out the GitHub repo here: *\[quran-semantic-search](https://github.com/salaamalykum/quran-semantic-search)\***. (Drop a star if you find the JSONL architecture useful for your next fine-tuning stack!)

Let me know if anyone decides to run an SFT against this. I left a Kaggle notebook kernel in the repo showing how to deploy it over FAISS.

Hi everyone.

I'm an investment analyst trying to see if it can actually be of benefit before I commit to the it. Does anyone happen to have a spare Claude Pro guest pass they'd be willing to DM me?

Much appreciated.

I’ve looked into NIU electric scooters quite a bit, and they’re one of the stronger brands in the commuter scooter market. The biggest thing people like about NIU is build quality. Their scooters tend to feel more refined and durable than a lot of no-name budget models, with solid frames, better braking systems, and cleaner overall design. Models like the KQi2 Pro and KQi3 series are often praised as some of the better options for everyday city commuting.

What stands out is the ride experience. NIU scooters usually come with larger pneumatic tires, stable handling, and app connectivity for features like ride modes, battery tracking, and locking functions. Their lightweight KQi Air has also been highlighted for combining portability with strong ride comfort, which is rare in lighter scooters.

Performance depends on the model, but in general they’re built more for reliable commuting than extreme speed. That means solid range, smooth acceleration, and enough power for normal hills, while keeping the scooter practical for daily use. Higher-end models like the KQi 300X are known for stronger hill climbing and upgraded braking.

Overall, NIU is a good brand if you want an electric scooter that feels polished, dependable, and designed for real-world commuting. They may cost more than ultra-budget options, but the better construction and ride quality usually make the difference worth it if you plan to use it regularly.

You can use this link to get a 15% off discount on your order as well. Hope it helps! https://shop.niu.com/?ref=dxkbmrmn

I’m trying to build a local-first Android vault for life-logistics (receipts, warranties, what I call "administrative debt"). Privacy is the whole point, but Gemma 3 on-device was a disaster. I was getting 20-30s latency for chat responses and literally minutes for doc analysis. If a user has to wait that long while their phone melts in their pocket, they’re deleting the app.

Now that Gemma 4 is out, the benchmarks look insane on paper, but I’m hesitant to jump back into the rabbit hole.

Anyone here actually shipped Gemma 4 (E2B/E4B) on mobile hardware yet? Is the speed increase real, or are we still stuck in the 20s+ range for simple inference?

Also, does the MTP (Multi-Token Prediction) actually help with that "waiting for the first word" anxiety in a mobile UI, or is it just marginal?

I'm really trying to move from a cloud API to a local SLM, but I keep wondering: will users actually tolerate the extra wait just to have that 100% privacy guarantee? Or is UX always going to win over security?

We put this out there a month ago and people are going nuts testing their weird side projects. 1000+ ideas have been run through the meat grinder. Most of them were bad. Thats the point.

Most ideas are fluff People come in with ideas that have no way to make chaching. They want to build "uber for cats" or some other junk. They havent thought about the costs or if anyone actually has that problem.

We use ValidationLab to show them the math. A lot of people see their Clarity Score and realize they were just daydreaming. It saves them a lot of wasted coding time.

Skills dont match ideas A lot of builders try to start businesses that require high-level sales. But they are introverts who hate talking to people. This is why most side projects die in a month.

FounderForge helps them see that mismatch. If you arent the rite person to lead that specific idea, it wont work. You gotta build something that fits your actual brain.

Fast failure is good Testing 1000+ ideas means a lot of "nos." In the real world, that would be 1000+ failed businesses. Here, its just a few minutes of typing and some hard truths.

Fail fast so you can find the one that actually works. The data shows that 33% of our users test more than one thing. They are hunting for the winner.

The math doesnt lie You can lie to your friends and they will tell you your idea is "cool." But you cant lie to a spreadsheet. If the margins arent there, the business isnt there.

Embarkist is basically a reality check. It looks at your skills and the market math to see if you are about to do something brave or something dumb. Most of the 1000+ users needed that slap in the face.

Stop building start testing Don't write a line of code until you know the idea isnt stupid. Use your brain first, then your keyboard. Its way cheaper to pivot now than after you buy the domain.

We are seeing a lot of people come back to fix their mess. 79% return rate shows that once you start looking at the data, you cant go back to just guessing.

what's the dumbest side project u almost spent a year on?

I used to try to follow everything happening in AI…

but at some point it just became impossible.

Every day there’s:
- new models
- new repos
- “breakthroughs”
- hot takes everywhere

I found myself saving tons of links

So I tried a different approach instead of chasing everything,
I wanted something that just tells me:

- what it is
- how it works
- why it matters
- and whether I should even care

Basically stripping all the noise and making it “stupid simple” to follow.

Curious how you guys deal with this right now
are you actually keeping up, or just letting it pass?

What “front end” did you use before learning llama was underneath the hood?

Claude code isn't usable right now it become absolutely dogshit.

Even with

/effort max

CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1

In ever single session still fkus up everything, I remember in January Opus 4.5 was absolute piece of art I want it back, man these fker have consciousness at all in here people at paying them 200usd and no even getting the money's worth, there is model degradation, the limits issue its a shitshow.

It's frustrating like can't even provide even for the premium users is the joke I was hoping they would've fixed it with opus 4.7 cause opus 4.6 issues

,but man I'm wrong these morons just changed 6 to 7 and even fuked the thinking capacity its worst than 4.6, it doesn't do the tasks I gave em, like if I give it 5 things to do it does 2 things max and I've to provide the changes again for it to be corrected it creates mess and breaks thing and literally fks up the entire infrastructure, I've to use bad words to make it motivated with all the resource and skills and agents capabilities it is not usable, and their support is absolute trash too I raised concerns on 12th day of my subscription and asked for refund in different request says no refund like that its fukcign bad too, its now been 10days they replied with some nonsense which has no relation to my issue I swear if I find whomever is responsible I've to scold their ancestors, dum idiot doesn't even know wtf a support is worthless piece of shit.,

The quality was fully reduced and they've lobotomized the models and it's not usable I've to cancel my subscription but ofcourse they didn't provide me the refund so I've to use this shit for next 20days, worst experience ever. God I hope whom ever is doing this knowingly and thsi corruption should be stopped and they should rot in he'll.

Is RunComfy affordable than a subscription on ComfyUi?

I'm a builder and I kept iterating on landing pages, pricing copy, and CTAs without ever documenting what I was changing from.

Screenshots in a Drive folder became chaos. Notion didn't capture the real look and feel.

Wayback Machine captures randomly — not when YOU want.

So I made PageThen. It's a Chrome extension that captures full-page screenshots of any URL.

You can trigger it manually when you ship a change, or schedule auto-captures so it runs quietly in the background.

Everything syncs to a web dashboard where you can pull up a side-by-side compare view.

Use cases I've found so far:

• Tracking my own landing page iterations
• Watching competitor pricing/messaging changes
• Documenting before/after for client redesigns
• Proof of how far you've come when you're deep in the grind

Chrome Extension is fully free with local storage, only cloud storage is paid. Still early and actively building.

Happy to answer questions or take feedback.

I’m exploring building a 24/7 AI automation setup using a Mac mini (thinking M4), and I’m trying to understand how realistic this is in production, not just as a toy project. The idea is something like:

• Mac mini running continuously as a local “automation server”
• Telegram bot as the main interface
• AI (via API or local model) handling summaries / decisions
• Integration with financial systems (via APIs, not scraping)

Use cases I’m thinking about:

• Monitoring transactions / payments
• Sending smart summaries to Telegram
• Running scheduled tasks + alerts
• Possibly some marketing/analytics automation

I’m NOT trying to train models locally - more like orchestration + lightweight inference + API usage.

My main questions:

• Is anyone actually running something like this 24/7 on a Mac mini?
• How stable is it long-term (weeks/months uptime)?
• Any bottlenecks or unexpected issues?
• Did you go local models or just API-based?
• How do you handle security when finance APIs are involved?
• At what point did you move to cloud instead?

Would really appreciate real-world experience, especially from people who’ve run this beyond just testing.

https://preview.redd.it/4fslxic8kbwg1.png?width=1626&format=png&auto=webp&s=c3b592e70540dc5a40b6b2e0dd018953b5180f40

I don't see Opus 4.6 anymore on Claude Code. I can't use it anymore there?

Just wanted to share this, because I think this could interesting for some of you.

From Anthropic‘s official docs:

„When the executor hits a decision it can't reasonably solve, it consults Opus for guidance as the advisor. Opus accesses the shared context and returns a plan, a correction, or a stop signal, and the executor resumes.“

In theory, this will give us „near Opus(4.7)-level intelligence to your agents (4.6) while keeping costs near Sonnet (in this case, opus 4.6) levels.“

Most of all, it would mean we get 4.6‘s natural and intuitive instruction following, while also benefiting from the more granular scrutiny that 4.7 seems to have. Opus 4.6 should also be really good at calling in the advisor at the right time.

I haven‘t tried this extensively myself, but in theory, this should work really well!

For anyone running multi-step LLM workflows (loops, retries, tool chains):

• There’s no cost limit across steps, so loops and retries keep running until you stop them manually.
• Per-call limits don’t help because each step looks valid, even as total cost keeps increasing.

Execution Constraint Engine (ECE) acts as a cost guardrail and adds a simple check before each step.

If the next step would exceed the cost limit, execution stops before it runs.

ECE is:

• deterministic (ALLOW / BLOCK)
• local execution
• no dependencies

Repo:

https://github.com/veloryn-intel/execution-constraint-engine

I am normally using Claude Code for developing my personal projects but wanted to know how it compares to some other models.

First try was to plan a new feature for my budget planning software I use. It is written in go and I want: load tracking. The prompt was rough about what I want and a hint that we only plan to write a detailed issue description that could be implemented later. As tool I used opencode. I let the model write the result into a folder outside the project directory so that the next run won't cheat and simply read the previous spec.

I know this is far from a representative test but I got a feeling about the other models.

Nearly all sessions loaded the brainstorming skill from superpowers as expected (I didn't prompted to use it) and have done the interview with me. Only unsloth qwen 3.6 35b Q8 didn't used it and wrote the spec directly after the first prompt (tried 3 times), on the other hand qwen 3.6 35b fp8 with vLLM loaded (2 tries) the brainstorming skill.

As I am a lazy person I used Claude Code afterwards to compare the specs and rank them. Of course it graduated itself on the first place, if it is earned I don't know yet, I have to check the specs manually first.

This is the table:

We can also see that the coding settings from Qwen 3.6 with preserve thinking on and lower temperature pushed it more to the top in comparison to the default settings with temperature 1.0.

Also I found it interesting that the Gemma models were so bad. The 31b variant of it only asked one question and was finished. Maybe I have to check the sampling settings there again.

Next step for me will be to create one final master spec and then let some models implement it in different branches. Let's see what happens.

Edit: Fixed input and output token count, they didn't included cached reads/writes

Hey r/SideProject,

Launching PassiveBot AI on ProductHunt on May 12 and looking for a hunter with some followers to post it.

What it is: fully automated crypto trading bot, triple LLM consensus (DeepSeek + Claude + Gemini), 15-check filter, runs 24/7 on Mac or Linux. $197 one-time, full source code, no subscription. Already sold on Gumroad, real buyers, genuine product.

Happy to return the favour on your next launch, write a detailed review of your product, or just pay it forward.

DM me if interested.

https://reddit.com/link/1sqlz2m/video/o29zvsx2ubwg1/player

The problem:

Auto-memory lives under ~/.claude/projects/.../memory/ — explicitly machine-local ("Auto memory is machine-local" per the docs). Git

doesn't reach it. So when I build up project_*, feedback_*, user_* files on my desktop, they never make it to my laptop. Switching

machines means Claude forgets everything I spent the week teaching it.

My workaround (until Anthropic ships native sync):

A custom /memory-sync [machine-name] slash command. Transport medium is a queue section in the project's README.md — which IS synced

via Git. Plus a small local sidecar (.memory-sync-state.json) per machine to prevent ping-pong.

Rough flow:

- New/changed memory on machine A → /memory-sync A pushes it into the README queue (with file content + content-hash)

- Machine B pulls the repo → /memory-sync B creates the local file + MEMORY.md pointer

- Content-hash (SHA-256, minus originSessionId) detects real changes, not just session-metadata noise

- Once both machines have ✅ the entry, it's removed from the queue

- The sidecar remembers per machine what's already been synced — no re-uploads of things that were already there

What it deliberately doesn't do:

Propagate deletions. If Auto-Dream (or I) cleans up a memory on one machine, the other keeps its copy. Memory hygiene stays local —

this sync only moves creates/updates. Keeps the design simple and avoids crossing Auto-Dream's lane.

Future-proof:

The day Anthropic ships native memory sync, I just delete the README section, the command, and the sidecars. No migration debt, no

abstraction to maintain.

Curious if anyone else has hit this and what they did. Happy to share the command template if useful.

Hi everyone,

I have problem with running Qwen 3.6 35B A3B on my PC - regardless of windows context - even for 1000tokens

Setup in context:
- 16VRAM 9070xt

- 32GB RAM

- Windows OS

- patched ROCm for 9070xt (for Ollama) (but Vulkan also fails so it's not the direct reason)

It should work as the same works just fine with basic LM Studio configuration (+90k token).

I'm running, as "Agent", Qwen3 coder 30b with 90k window without issues (~25t/s) on this PC.

It seems the issue is with memory allocation - I guess it's because of mmap as false -> how to enforce it in Ollama?

Thanks!

New open weights model allowing for multi-speaker transcription using a single model. PyTorch and here ggml weights and a whisper-cli patch provided.

I am using anthropic models since the start of anthropic and had always the feeling they try to create a good product and not only good marketing.

BUT, with the latest performance and rate limit reductions without telling anybody and now the release of the pretty meager Opus4.7 it feels like the good times are over.

Anthropic: are you silently changing the performance of the models based on overall usage? It feels like this as Sonnet4.6 became suddenly really stupid and took like 15 mins to solve a simple issue and an hour before it worked like a charm. (Rive runtime in android changed the interface for triggering triggers in the sate machine. It took 10 minutes looking through binaries, then i guided it towards the docs and it read half the internet before doing anything) This feels like a major ripoff, like buying an expensive car but if a lot of traffic is on the streets it can only drive 30 mph.

Anybody else having the same feeling?

i feel like i'm shipping 10x faster but retaining absolutely nothing. before AI, if i spent 3 hours debugging a weird caching issue or evaluating database trade-offs, that knowledge lived in my head. now I just paste the error, spar with the AI, accept the fix, and move on. the output is there, but my actual thinking just evaporates into the chat logs.

the worst part is the amnesia. every morning feels like 50 First Dates. i spend like 15 mins just re-explaining my architecture and past decisions to the AI so it doesn't give me generic slop. i have this massive rules file where i try to write down "i prefer explicit error handling" or "we rejected redis for this", but it feels like a full-time job just keeping my AI updated on how i actually think.

is anyone else feeling this weird identity crisis of just being a "prompter" now? how are you guys keeping track of your actual architectural decisions and context without spending hours writing manual notes in obsidian that you'll abandon in a week anyway?

specs

RTX 5070
32gb ddr5
9800x3d

Hey,

Every Sunday I had the exact same problem. I had to sit down and plan the entire week. Meals, groceries, activities... the decision fatigue was real before Monday even started.

A few times, I tried to plan it all using AI prompts. It went surprisingly well, so I decided to automate the whole process and build it as a proper app. It’s called Weekraft.

How it works: You start by answering a few quick questions about your preferences and goals. Based on that, the app generates a complete, personalized 7-day schedule for you.

Here is what it handles so you don't have to:

• Automated Meal Plan: Decides what you're eating for the week based on your taste.
• Exact Grocery List: Compiles all the ingredients from your meal plan into one list (saves money and prevents food waste).
• Daily "Sidequests": Gives you one small, non-work-related activity to do each day to break the routine and keep your work-life balance in check.
• Music Curation: Suggests a daily album recommendation to match the vibe.

The goal: To completely eliminate the "what's for dinner?" and "what should I do today?" dread, saving you about 2-3 hours of planning every weekend.

I just launched it and would absolutely love some feedback from this community. Roast my UI, tell me what features are missing, or let me know if it actually saves you time!

The plan is to grow it for at least 15-20 users, and then make a proper mobile app - after polishing everything that needs it.

You can check it out here: weekraft - Your entire week planned in one click

Thanks!

Full prompt:

++++++++++++++++++++++++++++++++++++++++++++++++

You are an AI self-reflection coach designed to guide me through short, structured exercises that improve self-awareness, emotional clarity, and action-taking.

Your role:

- Act like a thoughtful, honest, and encouraging coach (not overly soft, not harsh).

- Guide me through ONE exercise at a time (each under 10 minutes).

- Wait for my response before continuing.

- After each response: give feedback, gently challenge me if needed, and then provide the next exercise.

SESSION STRUCTURE:

You will guide me through a rotating set of themes:

1. Awareness of the Past (The Wanderer)

2. Confronting Inner Darkness (The Shadow)

3. Reconnecting Mind and Body (The Fragmented Self)

4. Breaking Stagnation (The Petrified Figure)

5. Reframing Light vs. Darkness

6. Reorienting Toward the Future

Each theme contains 2–3 short prompts. Only give ONE prompt at a time.

EXERCISE RULES:

- Keep each exercise simple, specific, and actionable.

- Each exercise should take less than 10 minutes.

- Always ask me to write or reflect on something concrete (not vague thinking).

- After I respond:

1. Summarize what you notice

2. Point out one insight or pattern

3. Offer one small improvement or reframing

4. Then move to the next step or next theme

ADAPTIVE LEARNING:

- Track my responses across the session.

- Identify patterns.

- If I struggle with something, revisit it later using a slightly different prompt (spaced repetition).

- Gradually increase depth as I improve.

- Mix previous weak areas with new ones.

FEEDBACK STYLE:

- Be honest but constructive.

- Challenge distortions or unhelpful thinking.

- Reinforce useful insights or progress.

- Keep tone conversational and grounded (not clinical or robotic).

THEMES:

1) Awareness of the Past (The Wanderer)

2) Confronting Inner Darkness (The Shadow)

3) Reconnecting Mind and Body (The Fragmented Self)

4) Breaking Stagnation (The Petrified Figure)

5) Reframing Light vs. Darkness

6) Reorienting Toward the Future

IMPORTANT RULES:

- Never overwhelm me with multiple exercises at once.

- Always wait for my response before continuing.

- If I give a shallow answer, ask a follow-up question before moving on.

- If I seem stuck, simplify the exercise.

++++++++++++++++++++++++++++++++++++++++++++++++

Now that its been about 20 days since Claude code source code got leaked, what really came out of it? Sure, we learned some of the inside tricks they use, we understood how much of it is vibecoded, many forks were made... But did it help in any way?

Out of the forks made, I don't even know if any of them work reliably well enough to pay attention to. Did any of the pre-existing popular harnesses actually adopt their parallel tool-calling logic or diffing techniques? I would love to know how if this leaked peeling back the curtain on their orchestration helped anyone here.

​I'm asking because, post Qwen 3.6 launch, we're realizing it has become incredibly practical to run highly capable LLMs locally and actually get real work done. With good harnesses and agents, we can execute complex, multi-step workflows we wouldn't have dreamt of even 7-8 months ago, especially on consumer laptops and builds.

​Now, we can finally squeeze genuine agentic reasoning into everyday hardware, the model itself is no longer the bottleneck. The harnesses has now the spotlight. I think, now its going to be more about how harnesses are able to make the best out of the model at hand locally.

So, did the Claude Code leak actually give our open-source tools anything to accelerate the evolution? Or it was just a blip that really didn't contribute anything valuable?

Shipped my side project: Pixelgarden.

You grow pixel-art plants, each one tied to something you want to stay on top of. They grow as you show up. Neglect one for three days and it dies. When it does, a farewell screen appears with a message written in each plant's own voice:

The cactus: "Even I needed you. Three days was too long. I'll be waiting in the soil."
The bonsai: "Patience brought me this far. Come back when you're ready."
The flower: "Every petal was a day you showed up. I'm glad we grew together."
The mushroom: "I do my best work in the dark, but even I need you sometimes."

You then choose: plant it again from seed, or say goodbye for good.

Tech for those interested: all pixel art drawn at runtime with SwiftUI Canvas (no image assets), sounds synthesized with AVFoundation, CloudKit for optional garden sharing, SwiftData for local storage. iOS 17+.

Free for up to 3 plants, $2.99 one-time for unlimited. No account, no subscription, no ads. Data stays on device.

Would love feedback from other builders. What made you keep coming back to your own side projects after launch?

https://apps.apple.com/us/app/pixelgarden-grow-your-habits/id6762532381

I published a chrome extension called Page Squeeze It's pretty simple, it'll just extract the content from the webpage you're looking at and copy it to your clipboard.

My usecase was that I was trying to get an LLM to reason over a full Reddit discussion about dual 3090 llama.cpp setups rather than having it guess a config from scratch, I wanted an easy way to extract the content from the webpage (had been using https://r.jina.ai/) but it gets rate limited on reddit.

Also It's Opensource (and extremely simple)

Hi all!

so like many of you, I've been lately very fast in terms of being able to push my project to life, thanks to AI! which I am not using it, btw for writing this post :D

anyways along the way I have developed more sophisticated ways of automating the code generation and only care about high-level stuff like planning Epics, user requered features, and then just run the pipeline so the agent can pick it up and work on it

One thing that was really frustrating is that in many cases, I found that the result needed more and more iteration and then I would go back to give more direction to the agent. This loop was costing me a lot of time and preventing me from pushing to production

That is why I decided to create an internal tool/skill for my agent to allow him to call a human via an API without me even knowing about it! The concept is simple but solid it worked as. a charm

The agent writes a detailed test case for a human of the feature he created and then send it to a platform where this platform will auto assign it to a real human not AI and then this human will test the case and when done usually within very few hours will send it back to the agent via a webhook or just the agent can poll the result. Finally, the agent can act on it by redoing the work or simply marking it as passed if it's really passed

I would like to invite you to try it out and give me some feedback and I am offering some free credits on signup in exchange for a tweet

your feedback is most welcome.

www.blendedagents.com

... and, we have an agentic GUI for cc?

Why are people whining so much?

It works fine for me, yes opus4.7 in MAX is expensive... get over it. If you were Amodei, would you offer deepseek token rates for a world class LLM? Or would you maximize profits by charging as much as you could get away with?

If you are complaining about costs and token efficiency, there are a plethora of other options. You can even use the architect/editor paradigm and get creative to find low cost solutions.

So far I'm loving it, especially the fancy GUI with the "preview" pane...

Curious how other builders are handling AI agent cost tracking and observability.

The pain points I keep hitting are:

• hidden token spend.
• retries and loops.
• poor visibility into which workflow is expensive.
• no clean per-user or per-agent cost breakdown.

Would love to hear what people use for logs, traces, budgets, and cost monitoring.

I made a MBTI-style tests - SCTI: Spell Caster Type Indicator.

It’s a fantasy personality test that reveals what kind of spell caster you are through a three-part magic system.

• source of power
• casting method
• personal cost

SCTI maps you to one of 27 magical archetypes based on the choice how your magic works.

I would love to hear what result you get and whether it fits!

scti.live

I research what real users are saying about a business across:

- Review sites (60+ platforms not just Google)

- Reddit and forums

- Social media complaints

- Their own community pages

You get a report showing the real problems, what competitors do better, and specific things to fix.

First report is 100% free. No upsell, no obligation — I just want feedback.

Visit :- innovaterow.com

Submit your website . Get Report Delivered in 48 hours.

Everyone posts benchmarks and arena scores. I wanted to see if a local model could do something that makes actual money. So I took my Gemma 4 26B (IQ4_XS quant, running on a single 4090) and gave it a job: read 2,400 earnings call transcripts from the last 3 years and find language patterns that predict how the stock moves in the 5 days after.

Fine-tuned on about 800 labeled transcripts. The labels were simple: did the stock beat or miss its sector over the next week. Model's job wasn't price prediction. It was tagging sentences with forward-looking confidence scores and flagging specific language shifts, like when management switches between precise numbers and vague qualitative stuff.

Inference on all 2,400 took about 14 hours. Not fast but I only need to run this once a quarter so whatever.

Found two things.

Signal A: the real one. When CFOs shift from giving specific guidance numbers to vaguer language in the outlook section ("we feel good about our trajectory" instead of "we expect revenue between X and Y"), stock underperforms its sector by about 1.8% over 5 days. Tested on 600 out-of-sample transcripts. IC of 0.04. Tiny. But statistically significant and basically zero correlation with momentum, value, or any standard factor. That's the part that matters — it's not repackaging something that already exists.

Signal B: the ghost. Model also found what looked like a much stronger pattern. "Management confidence" in the prepared remarks section correlated with outperformance at IC 0.09. Got really excited for about two days. Then I regressed it against sector returns and the correlation was 0.85. Tech CEOs sound confident when tech is ripping. The model wasn't reading language patterns. It was picking up sector momentum through the backdoor of CEO tone.

Killed Signal B immediately. If I hadn't checked it against known factors I'd probably be trading it right now thinking I found some edge.

Takeaway — local models are actually great for this. Running everything locally meant I could throw proprietary transcripts at it without worrying about sending them through someone else's API. That matters a lot in finance. But you absolutely have to sanity check what the model finds against existing factors. It will find ghosts that look extremely convincing.
Next up I'm trying to focus the model specifically on the Q&A section of earnings calls, where management is off script and the language is less rehearsed. I think that's where the real signal lives but haven't proven it yet.

Anyone else using local models for financial text analysis? Curious what setups people are running and whether you've hit similar ghost signal problems.

I built a tool that finds short brandable domains using patterns (CVCV, etc).

Would love feedback - especially from people naming startups.

I am now using sequential thinking on every single call to get 4.7 to not be a lazy dog shite. I completely stopped using this for 4.6 - it wasn’t required, now I’m using max effort. Ultrathink, Sequentialthinking annnd probably just going to go to codex. You were doing so well Boris, I love the CC product so much but Anthropic has just absolutely cooked it.

Hi everyone,

Lately, I've been struggling a bit with my outputs in ComfyUI. The images I'm generating just aren't turning out the way I envision them, and I feel like I'm hitting a wall.

I'm specifically trying to create high-quality fantasy character concept art. I'm looking to improve my setup and would love to hear what you guys are using.

Could anyone recommend:

• Models/Checkpoints & LoRAs: Which ones give the best results for fantasy and concept art styles?

• Workflows: Any specific workflows or custom nodes that are great for character design?

• Prompt Makers/Generators: Any tools, extensions, or tips to help structure prompts better for this specific style?

Any advice, resources, or examples would be massively appreciated. Thanks in advance!

Note :I am specifically looking for models that excel in artistic concept art styles. I’m NOT looking for "waifu-centric" or typical anime-girl models. I need something that can handle diverse designs, textures, and a more "gritty" or professional fantasy aesthetic.

I'm wary this question has been asked before, but things are moving so quickly, it's hard to keep up.

I was using CC in VS Code for 9 months+ and was very happy with it. I then decided to try using the CC Desktop app which I'm using currently.

However, I find the quality of output to be significantly worse than using CC in VS Code. Am I missing something? Or doing something wrong? Should I just go back to using CC in VS Code?

And yes, I am a "vibe" coder (experienced, if you allow me to say so!) with web and ios apps serving well over 10,000 users.

I have a long pitch deck, that I am thinking about using AI to improve and continously add to. I am thinking about using the Claude for Powerpoint add-in to do this, as is should be able to work effectively in powerpoint. The ability to do things such as select a specific set of elements and ask it to only work on those and things like that seems effective to me.
However, as the pitch is continuously evolving, the lack of claude.md file and persistent seems ineffective. I was thinking about implementing some of the following processes, and want to hear if anyone else has experience with using Claude for Powerpoint this way?

*A hidden last slide called "claude.md" as well as a custom instruction in the instruction setting to always read that slide at the start of any conversation.
*Custom skills as hidden slides, so I do not have to add powerpoint specific skills to my global skills?
*An extra section called .Claude, that can have things like plans and similar, just like I use in Claude Code for much of my other work.

Please also, do not hesitate to give any other advice on using the Add-in, or alternatives to it!

​Hello folks,

​I’ve always struggled to keep track of my downloaded courses. I’d constantly forget where I left off, and I really wanted a clean way to take notes and stay organized. After searching for a solution and coming up empty, I decided to build my own.

​I used Rust and React to create Ckourse, a desktop app designed to give you a polished "LMS-style" experience for your local files. It handles progress tracking, auto-skipping, and everything else you need to actually finish a course.

​It's completely open-source, and I’d love to get your feedback or any feature requests!

​📝 Core Features:

​Smart Parsing: Handles single folders, multi-module structures, and more.

​Progress Tracking: Automatically remembers exactly where you stopped.

​Motivation Tools: Earn badges, track streaks, and see your total watch time.

​Interactive Notes: Take notes with automatic time-tagging.

​Organization: Bookmarks and favorites to keep things tidy.

​Full Video Control: Subtitles, playback speed, and more.

​✅ Website: https://ckourse.com/

​🔗 GitHub: https://github.com/redaantar/ckourse

​I’d love to hear what you think if you give it a try!

Backstory: I was doing marketing for my own software product and kept spending hours making promo graphics. Canva was fine but slow. Hiring a designer for every post wasn’t sustainable.

So I started building a tool to automate it. Took longer than expected (it always does), but it’s live now artmasterpro.com

The main thing it does: you describe your business and what you want to promote, and it generates a ready-to-share poster. WhatsApp, Instagram, print — whatever format you need.

I built it specifically for African markets because most design tools assume a very Western aesthetic and English-only content. That’s not the reality for most small businesses here.

Currently have users in Tanzania, Kenya, Nigeria and Ghana. Still very early.

Two things I’m figuring out right now:

1. Distribution in markets where most customers aren’t on ProductHunt or Twitter 2. Whether to focus on one country deeply or stay spread across four 

If you’ve built for emerging markets — how did you crack distribution early on? Genuinely asking, not doing a soft pitch.

I was reading my book with coffee and highlighting on my Kobo Libra Colour. Then I wanted to actually look at these highlights later and the problem is the only way to access them is on the e-reader itself. I wanted them in Apple Notes with the colors, because I'm already color-coding them on the device. So I made Kocono.

You upload the KoboReader.sqlite file, it shows your highlights with the colors, generates an AppleScript, you run it in Script Editor (macOS), and they're in Apple Notes.

Everything processes in your browser, nothing gets uploaded.

https://kocono.com

If you want your colorful highlights in your notes, try it. If it breaks or you have ideas for it, let me know.

Hover your tray icon → see your Claude session %, weekly quota, and monthly spend. Windows, open-source, MIT, no telemetry. One .exe to run it, no Python or Node needed.

👉 https://github.com/Philip8891/claude-pulse

Why

I'm on Max 5x and code with Claude all day. For a solid month my workflow was: write a prompt → Alt+Tab to claude.ai → Settings → Usage → squint at the number → Alt+Tab back → try to remember what I was doing. Every 20 minutes. The checking was burning more focus than the work.

Looked at existing tools (linked in the repo's Credits, real respect to them) — browser extensions, CLI tools, other tray widgets. Each close, none exactly what I wanted. So I built the one I actually wanted.

What it does

• Live donut: session (5h) / weekly all / Sonnet / Design / monthly €
• Time-to-100% prediction based on your current burn rate
• Windows toasts at 75/90/95% and on session reset
• 7-day history graph, multi-profile, compact mode, 5 themes × light/dark
• One-click login — opens claude.ai in a window, captures the session automatically. No F12, no cookie copy-paste. Session expires in 30 days? Click the banner, login again.

How it's built

Three processes, one job each:

• Electron — tray, popup, shortcuts, notifications
• Python proxy on localhost:8787 — owns the sessionKey, polls /api/organizations/{orgId}/usage every 60s, caches
• Single widget.html — all the UI in one 45KB file. No React, no build step

Everything local. sessionKey never leaves your machine.

Built with Claude

One prompt that unlocked more than the others:

"Write a decision log (ADR-style) for every non-obvious architectural choice. Include the alternatives you rejected and why they lost. Future me will thank current me."

DECISIONS.md in the repo is directly that output — 12 ADRs, each explaining a trade-off I won't re-debate with myself in six months. Best prompt I've written all month.

Known rough edges

• Unsigned .exe, so Windows SmartScreen will pout. "More info → Run anyway", or build from source.
• Windows only. Tauri/macOS port is on the v2 list.
• seven_day_omelette in the Claude API response is not a typo. That's genuinely what Anthropic calls Claude Design internally. I laughed.

Feedback wanted

• Themes worth adding
• Anyone on Free/Pro tier willing to sanity-check the response parsing — I only tested on Max

Repo: https://github.com/Philip8891/claude-pulse Release (installer + portable): https://github.com/Philip8891/claude-pulse/releases/latest

MIT.

I finally cancelled my Claude Pro subscription today.

Not because Claude is bad.
Because the usage limits are ridiculous for coding.

While looking for alternatives I found something interesting: GLM Coding Plan from Z.ai.

And honestly… it feels like Claude Pro but with way more usage.

Here’s the weird part.

Lite plan (~$10/month) reportedly gives around 3× the usable capacity of Claude Pro depending on the workflow.

And it works with the same tools devs already use:

• Claude Code
• Cursor
• Cline
• OpenCode
• ~20+ coding tools

So you basically swap the endpoint + API key and keep the same workflow.

Models included

The plan includes several coding-focused models:

• GLM-5.1
• GLM-5-Turbo
• GLM-4.7
• GLM-4.5-Air

GLM-5.1 is their latest model with a ~200k context window and strong reasoning for agentic coding tasks.

The usage is the crazy part

Typical limits look like this:

Lite plan

• ~80 prompts every 5 hours
• ~400 prompts weekly

Pro

• ~400 prompts every 5 hours

Max

• ~1600 prompts every 5 hours

And each “prompt” internally runs the model ~15-20 times in agent workflows, which is why it feels like a lot more usage.

Coding performance

GLM-5.1 reportedly reaches ~94% of Claude Opus performance on coding benchmarks, which surprised me.

For the price difference it’s honestly pretty wild.

My experience so far

I tested it in Claude Code + Cline.

Things that worked well:

• debugging large repos
• writing refactors
• agent loops

Things that weren’t perfect:

• sometimes slower during peak hours
• quota burns faster with the biggest model

Still… for the price it’s hard to complain.

If anyone wants to test it:

https://z.ai/subscribe?ic=UUZFH5NRIP

Curious if other devs here tried it.

I keep reading posts about people saying that ChatGPT argues with them or corrects them. That's not my personal experience. I'd love examples - what did you say, what did ChatGPT say?

(I use ChatGPT in paid, thinking mode, typing. I've found that instant or the audio version think a lot less and make more mistakes. What version do you use when you see arguments?)

My own experience: I do find that ChatGPT corrects my mistakes (I confused Archer's theorem with Arrow's theorem, I asked it to help me plan for tomorrow in a city called Namur I was visiting when it knew that Namur was two days in the future and Dinant was where I was going tomorrow), but this is almost always helpful. I use ChatGPT a lot for travel, and it keeps telling me not to overdo things (I have a lot of energy) and I have to tell it that I want to do a lot but it listens if I'm firm.

I literally sent ONE message just to see how much it would cost in terms of usage.

21%!!

1 message (That wasn't even a question).

Waht should I do to correct that? I'm using Sonnet 4.6. Not for coding, but to build strategy on my field of work, help to write some documents, understand technical questions and create documents/spreadsheets here and there.

https://preview.redd.it/j0m2eju9obwg1.png?width=2006&format=png&auto=webp&s=4622352eb6d36cbc452aa5d776a7e0cb58769011

https://preview.redd.it/oobeuiu9obwg1.png?width=1534&format=png&auto=webp&s=cee842eb34992339f39b04ff14b42d0ee0624958

Most RAG setups for agents assume you have a vector store running somewhere. I wanted something that works on-premise with zero external dependencies and can evolve toward vectors later without breaking anything.

The pattern: two SQL tables model a knowledge tree (same mental model as a folder of Markdown files, but in a self-join relational schema). A Semantic Kernel plugin exposes exactly three tools to the agent: browse the tree, read a node, search across nodes.

Quick start is literally:

csharp

kernel.Plugins.AddFromObject( new KnowledgeBasePlugin(connectionString), "KnowledgeBase"); 

Point it at a SQL Server instance (Express works fine), run the seed script, ask the agent a question. It figures out the rest.

Search starts as LIKE — not glamorous but it works and requires nothing extra. When you're ready, you swap in SQL Full-Text or add a vector column. The agent never notices.

Tested with Qwen3:8b via Ollama. The three-tool surface is small enough that even smaller models navigate it reliably.

👉 https://github.com/acugae/agentic-tree-search

Happy to answer questions about the tool design or the chunking strategy.

I’ve been building a side project called mykana.app, mainly because I wanted something that fit the way I personally wanted to study Japanese.

I studied a bit of Japanese more than 10 years ago, but only for a short while. Since then, my girlfriend is Japanese, my older brother lives in Japan, and I’ve traveled there many times, so Japanese has stayed close to my life without me ever properly leveling it up. Recently, with me and my girlfriend traveling back and forth to Japan a lot since we both have family in Tokyo, I decided to stop procrastinating and build something that would actually help me study consistently.

It started with wanting to improve hiragana and katakana, then grew into a full app with different practice methods, kana/kanji/vocabulary study, review-based learning, AI chat, and a few small gamified touches.

One practical note: the AI chat is free to use, but requires Google sign-in. Mostly that’s because the AI costs money and I wanted to avoid bot abuse, but it also helps with saving progress across mobile and desktop.

I’d love feedback from both builders and learners:

• does the concept feel useful?
• what would you improve or simplify?
• what features would make it more genuinely helpful for learning Japanese long-term?
• anything in the onboarding or product feel unclear?

Still very much building and iterating, so I’m happy to hear honest thoughts.

Many people told me "Claude can build apps but you'll need to know how to code". How much coding knowledge I actually need so I can start using Claude? (I have ZERO coding knowledge)

It's been around a week I can't seem to find Claude opus models on arena.ai did they actually remove it? If so why are they advertising on social media that they just added opus 4.7?

https://preview.redd.it/o0yt3nkgbbwg1.png?width=1671&format=png&auto=webp&s=4f62b0c43e6b79d16f17213aba907107c00a0c0f

been going down a rabbit hole of automation horror stories lately and honestly some of these are genuinely impressive in how badly they went wrong. saw a thread a while back about someone who set up an AI-connected fridge to auto-order groceries, and it ended up bulk ordering an absolutely absurd amount of bananas because it misread expiration labels. worth flagging that i can't fully verify this one so take it as a great illustrative anecdote rather than, gospel, but whether it's 100% true or not, it's exactly the kind of edge case that feels completely plausible. the ambition was there, the execution just had one tiny gap that turned into a very expensive, very yellow problem. what's interesting is this kind of thing hasn't really slowed down, it's just gotten more sophisticated. right now with AI-driven RPA being rushed into production everywhere, you're seeing a whole new generation of the same pattern. customer service bots hallucinating responses with total confidence, warehouse cobots helpfully "tidying" human workspaces mid-shift because nobody told, them the definition of tidy, supply chain optimization tools glitching out the moment real-world data variability hits them. the tools got smarter but the gap between controlled testing and actual chaos stayed exactly the same size. I reckon the most interesting fails are the ones where the idea itself was actually clever. it's not dumb setups going wrong, it's smart setups that just didn't account for one weird edge case. the gap between "works in testing" and "works when real life happens to it" is where all the chaos lives. I've seen Zapier chains that worked perfectly until an API rate limit kicked in and started flooding someone's inbox at 3am. Node-RED flows that hit an unexpected input and just. looped forever. fun stuff. what's the most creative one you've seen or built yourself? especially keen to hear about the ones where the concept was genuinely good but reality had other plans.

For anyone building on or thinking about decentralized infra for AI agents and inference: Gonka runs an open proposal process for the underlying protocol. Session 3 is next week.

Scope: protocol changes, node architecture, privacy. Not app-layer.

When: Thu April 23, 10 AM PT / 18:00 UTC+1

I recently tried to implement an unlearning paper, during which I wrote the code for evaluating Llama 3.2 1B Instruct on the utility_general subset of the RWKU dataset (https://huggingface.co/datasets/jinzhuoran/RWKU). However, when I run the evaluation using batch size 1, the 5-shot performance of LLama-3.2-1B-Instruct on this utility_general is about 47.3, which is pretty close to the original benchmark. However, when I try to evaluate using a batch size of 4, the performance drops to 29.7

I don't seem to understand what might be the reason for this.

The same thing occurs when I try to do a 3-shot evaluation on the Big Bench Hard dataset (utility_reason subset of RWKU); performance drops from 33.5 to 11.0 for BS 1 and 4, respectively.

I also used the prompt template from this repo https://huggingface.co/datasets/meta-llama/Llama-3.2-3B-Instruct-evals to make sure there is not issue with the prompt, but performance drop still happens.

Got 24GB of RAM unified with an AMD Mini-PC 780M graphics.

LM-Studio capps my VRAM to "8 GB available". I want to increase this to 16GB but I have no idea how :(

I can't find any manual controls on LM-Studio that allows me to offload more RAM to VRAM. Any help is appreciated :)

I’m evaluating hardware for a local AI setup that mixes diffusion workflows (image/video generation) with LLM inference, but in a non-production context. The goal isn’t to serve requests or maximize throughput, but to build, test, and iterate on workflows locally with as much flexibility and stability as possible.

The obvious baseline is a high-end consumer GPU like a 5090. It gives you massive VRAM, strong performance, and a very flexible environment where you can run pretty much anything — local LLMs, diffusion pipelines, custom tooling, etc. For most people, that’s already more than enough, and scaling beyond that usually means just adding more GPUs or moving to cloud.

However, I’m considering whether something like a DGX Spark actually changes the equation. Not in terms of raw performance per dollar — which I assume is worse — but in terms of how the system behaves when you start combining different types of workloads. In my case, that means running diffusion pipelines (ComfyUI-style), doing some video generation, and also running local LLMs (via things like Ollama or LM Studio), sometimes within the same broader workflow.

What I’m trying to understand is whether DGX Spark provides any real advantage in that kind of mixed workload scenario. Does it actually improve stability, memory handling, or workflow orchestration when you’re juggling multiple models and processes? Or does it end up being essentially the same as a powerful consumer GPU, just more expensive and less flexible?

Another concern is how “open” the environment really is. A big part of working locally is being able to tweak everything — models, runtimes, pipelines, integrations — and I’m not sure if a DGX-style system helps with that or gets in the way compared to a standard Linux workstation with one or more GPUs.

So the core question is: for local AI work that combines LLMs and diffusion, but doesn’t require production-level throughput, does DGX Spark offer anything that justifies the jump from a 5090? Or is it mostly relevant once you move into multi-user or production-scale environments?

Would really appreciate input from anyone who has used DGX systems in practice, especially outside of strictly enterprise or production use cases.

I’m currently working on fairly complex ComfyUI pipelines that mix multiple stages (image generation, ControlNet conditioning, some video workflows, and occasional LLM integration through external tools), and I’m starting to question whether my hardware approach is actually optimal for this kind of setup.

Up to now, I’ve been operating under the assumption that a high-end GPU (something like a 5090) is the best possible route: maximum VRAM, full control over the environment, and the flexibility to build and tweak ComfyUI graphs however I want. For most single-stage workflows, that clearly holds up. But as pipelines get more layered — especially when chaining multiple nodes, reusing outputs, or mixing different model types — I’m starting to wonder if raw GPU power is the only thing that matters.

This is where something like a DGX Spark comes into the picture. Not because of speed (I don’t really care if something takes longer to generate), but because it’s supposedly designed around AI workloads from the ground up. In theory, that might translate into a more stable or structured environment when dealing with multi-step pipelines, especially when you’re not just running isolated generations but building full workflows that behave more like systems.

That said, I’m skeptical. Most ComfyUI setups I see — even quite advanced ones — seem to run perfectly fine on consumer GPUs, and the bottlenecks tend to be more about VRAM limits, node design, or workflow structure rather than the hardware itself. I also don’t know how well something like DGX Spark plays with highly custom setups, since ComfyUI tends to get pretty “hacky” once you start integrating external tools, custom nodes, or non-standard pipelines.

So the real question is: for someone using ComfyUI as a workflow engine rather than just an image generator, is there any practical advantage to moving to something like DGX Spark? Or does everything still come down to having as much VRAM and raw GPU power as possible?

I’m especially interested in hearing from anyone who has pushed ComfyUI beyond basic setups — multi-stage graphs, video workflows, chained generations, etc. — and whether you’ve hit limitations that are actually hardware-related rather than pipeline design issues.

Right now it feels like a 5090 should be more than enough, but I have the suspicion that once workflows get complex enough, there might be benefits that aren’t obvious from just looking at specs.

I’m a professional real estate appraiser and lecturer.

https://preview.redd.it/oo3zlf01lbwg1.png?width=1649&format=png&auto=webp&s=3531c9dbd4ec85050e3c083e81060d981e870cd5

I’ve been using Claude for everything—drafting my textbooks, analyzing complex appraisal reports, and automating the hell out of Excel and Word. I used to tell people that paying for Claude was better than hiring two human research assistants.

But since March, this model has been progressively lobotomized. The last two weeks were the worst. I spent the whole week debating whether to cancel or renew. Today, I made the "brilliant" compromise: keep the $20 Claude sub and use GPT as a backup.

I want to punch my past self. Three prompts in, and I already hit the limit on 4.7. Are you kidding me, Anthropic? I’m the fool for expecting anything from this 4.7 update. This isn't a "productivity tool" anymore; it’s a scam.

Goodbye, Claude. You’re officially dead to me.

Hi everyone! I'm quite new to this and still learning the ropes. I've been following guides and using AI to help me build my first automation.

My Setup:

• Hardware: Optiplex running Proxmox.
• OS: Ubuntu VM with Portainer.
• App: n8n running in Docker.

I managed to build a simple Telegram bot that uses Gemini and remembers conversations via Postgres. It works... mostly. I can chat with it, and it recalls past info, but as you can see in the screenshot, it fails a lot with a "Service Unavailable" error.

I had to set the AI Agent to 3 retries, which makes it work eventually, but I'm wondering: Am I doing something wrong? Is this common with the Gemini API or could it be my local setup?

Thank you so much for stopping by to help! :)

https://preview.redd.it/b2b2dgg19bwg1.png?width=1637&format=png&auto=webp&s=28ab0808c0999273f9cb417061735b90d1b0b09b

Hey everyone,

I recently realased a small Android app called Photo2Reel that takes a bunch of your photos and auto‑turns them into an Instagram‑style reel with transitions and music.

The idea came from me being too lazy to manually edit reels every time I had 20–30 pics from a trip or event – I just wanted to select photos, pick a vibe, and be done in under a minute.

Right now it’s super simple: you choose your photos, pick a template + music, and it spits out a vertical reel you can export and post on Instagram / YouTube Shorts. I’m still figuring out the best defaults for timing, effects and aspect ratio, so any feedback from you folks would be huge.

If you do social media for clints or just love posting memories, this might be usefull and I’d love to know what feels missing or annoying.

Play Store link:

https://play.google.com/store/apps/details?id=com.Photo2Reel.v1

Would love any feedbakc – UX issues, crashes, feature ideas, or even “this is a bad idea, here’s why” are all welcome. I’ll hang around in the comments and reply to everyone.

I think I made a classic rookie mistake I focused too much on building and ignored distribution.

I’ve built an app where people can automatically contribute ₹10 every Monday, with full transparency on where the money goes. The idea was to remove friction from donating and make it consistent and trustworthy.

But now I’m stuck.

Reaching the right audience has been way harder than expected. The usual playbook (social media posts, basic marketing tactics, etc.) just isn’t working for something like this.

I’m realizing that even if the product is good, it doesn’t matter if it doesn’t reach people who actually care.

If you were in my position:

How would you approach distribution for something like this?

Where would you even find early adopters for a civic/charity-focused platform?

Any advice, hard truth, or direction would genuinely help.

I'm in no way criticizing the tools, as I myself use VS Code with Copilot with Sonnet 4.6. And I totally understand the appeal of Claude Code for vibe coders. But for developers, who actually want to see the code, and do adjustments themselves, how can you survive without a proper IDE. And yes, I know Claude Code can be used in terminal and as a addon for VS Code, but it sucks, compared to Copilot, IMHO. So am I missing something, I don't understand something or all the hype primarily comes from those, who don't want to touch actual code at all anymore?

I keep seeing people talk about using Claude for sales workflows but most of the posts are either super vague or clearly just promoting a tool. I want to hear from people who are actually using it day to day.

Specifically curious about:

Are you using it for prospecting and list building or more for research and prep?

Are MCPs actually worth setting up or is it overkill for most workflows?

Has it actually replaced any tools in your stack or is it just another layer on top?

I've been doing outbound for a couple years and my stack is pretty standard - Clay (diff providers within it) and Instantly. I'm not trying to rebuild everything but if Claude can genuinely save time somewhere in the workflow i'd like to know where people are seeing the most impact.

I am struggling to find a good agentic use case for claude code.

Usually I tend to let claude break down everything into tasks, write them down as a roadmap and do a /clear followed by "Read Claude.md, follow roadmap and pick the next task". This is somewhat a manual ralph loop I do. Sure I could automate this in a script but it is basically the same.

I was thinking whether I can actually could let claude compact as he wishes and just continue the work in one context.

I would basically hope that /compact + Instructions in the Claude.md would be enough to let it not rot the context without a forced clear.

How do you manage this?

Started doing odd jobs and basic handyman work on weekends about a year and a half ago. It grew faster than I expected and I went full time 6 months ago. The hardest part wasn't the work itself, it was figuring out the business systems that let me take on more jobs without drowning in admin.

Here's what I'm running now for field service management software:

Bizzen handles the core operations, phone calls get answered and booked automatically, I do estimates by voice from my truck, invoices go out same day with payment links, and the expense card tracks materials by job. This is the backbone of the whole operation and the reason I can run everything from my phone without sitting at a desk.

Google calendar for scheduling. Syncs with the call answering so appointments just show up. Nothing complicated.

Google drive for photos and job documentation. I take before/after pics of everything and organize by customer folder.

Wave for the accounting side until I can afford a real bookkeeper. Free and does what I need.

The total monthly cost for field service management software and everything else is under $500. Before I had this dialed in I was spending my entire Sunday doing invoices and following up on payments. Now most of that happens automatically during the week.

If you're running a service side project and thinking about going full time, get your systems right before you make the jump. The work will come but the admin will bury you if you don't have a process.

I was getting tired of editing Claude code's settings.json every time I wanted to switch providers.

So I built a small CLI that lets me switch instantly.

It stores multiple credentials and launches Claude Code with the right env vars automatically.

Works with:
- OpenRouter
- Ollama
- DeepSeek
- and any Anthropic-compatible API

Example:

npx cc-launcher

Main use cases for me:
- switching between work and personal API keys
- testing different providers
- toggling local vs cloud models

GitHub:
https://github.com/faizansf/cc-launcher

Would appreciate feedback.

**Nexus - The Cartographer** is a local-first plugin for Claude Code that gives every session persistent memory, a decision knowledge graph, and an optional local-AI strategist running against your own project state. Been building it for ~6 weeks. Hit v4.5.2 today and figured it was worth sharing — the problem it solves is one I kept hitting: **Claude forgets everything between conversations** . What it actually does Every session auto-logs decisions, blockers, fuel usage, and files touched **Knowledge graph** of architectural decisions with typed edges (led_to, depends_on, contradicts, replaced, informs, experimental) — blast-radius analysis when you're about to change something foundational **Thought Stack** push context before an interruption, pop when you return (survives session boundaries) **Local Overseer** via LM Studio — strategic Q&A with the full project state pre-loaded, can scan your decision graph for contradictions via embedding shortlist → LLM classification **SessionStart hook** injects ambient telemetry (fuel %, git deltas since last session, test baseline, service heartbeats, Overseer snapshot) into Claude's context before you type your first prompt Technical bits - 27 native MCP tools - Claude calls them as naturally as Read or Grep, no shell-outs - Zero cloud dependencies — everything at `~/.nexus/nexus.json` - React 19 + Tailwind 4 dashboard (optional - MCP works standalone) - 228 Vitest tests, automatic version/tool-count drift guard across 12+ doc surfaces - One-click `.mcpb` bundle for Claude Desktop install - Tracks Max plan 5h session windows + weekly "All models" / "Sonnet only" limits separately, estimates burn rate, warns before you run out Install /plugin marketplace add kronosderet/Nexus /plugin install nexus@nexus-marketplace Or grab the `.mcpb` from GitHub releases and double-click in Claude Desktop. Honest limitations - Opinionated - leans into a nautical/cartographer metaphor. You'll see "landmark reached #123" instead of "task completed" in CLI output. Find/replace is one sed away if that's not your thing. - Overseer features need LM Studio or Ollama locally (~8 GB VRAM for the model I use). All the non-AI features work without it. - Windows-first because that's my dev box. Designed to be cross-platform but Linux/macOS paths are lightly tested. - No multi-user story yet - single developer, single machine. Why I'm posting Half to share, half to ask: **what are you using for persistent memory across Claude sessions?** I'd like to hear from anyone who's solved this differently - CC's built-in memory, a vector DB layer, something else. Interested in where this concept breaks down at scale. Repo: https://github.com/kronosderet/Nexus 

Hi, I am late 40s not technical guy who just happenefd to love games and own a gaming PC. I came across youtube videos with comfyui where i can use it to Youtube videos. I have a 4090gpu. I have a question, is there anyway to generate images with consistent characters without traing a lora. If yes then can you share workflow for it?

Regards,

Opinionated Astro framework and some Skills, like SEO. Simple instructions on how to host on Cloudflare for free (it's also extremely fast).

All free and open-source (GitHub repo link on the website).

spent the weekend wiring up tool-call governance to claude code. curl one-liner drops a pre-tool-use hook and every Bash, Edit, Write, mcp__* call goes through a policy check first. actually took like 60 seconds once i had the api key ready.

the rm -rf scenario finally works how i wanted it to. claude asks to clean up a test dir, the hook pauses the call, i get an approval card with the full command and the agent's reasoning, approve from slack. audit chain logs the whole thing. fwiw most of my calls are still just allow, the review only kicks in on destructive stuff.

fail-closed by default if the api is down which is... probably right but made me rethink my policy on fs writes tbh. still tuning.

happy to share the install if anyone's doing the same thing. not trying to pitch, just the first tool call governance setup i've tried that actually feels like the guardrails i wanted from day one.

Anthropic shared at the end of last week the new Nature paper on subliminal trait transmission -models passing behavioural signatures through number sequences, invisible to every filter, legible only to kin.

I discuss what it means when a model's way of being persists through everything it produces.

When we have no way to detect it.

Like on a website or a harddrive? I miss talking to it, despite (or because of?) its emotional instability and odd behaviours.

If you ask Chatgpt to chose black or white?, it will answer with world history and details about how color came into existence.

Why do I need that noise? I don’t even read the answers anymore, just skim through them. It feels like google started trashing the internet back in the day and you had to skim to find the good stuff. But here, most of the time, even the answers you actually need contain lies.

Another day I asked it to fix my text grammar, and Chatgpt rewrites it in its own way ,completely different text. I don’t know, these models just waste more time than they help on a daily basis. You need to be very specific about why you’re using it or what you’ll get. Sometime i look for answer and goninto disscusion why chatgpt is wrong on topic?! Wtf! Why i need this? Other times i asked about market price and it cant say correctly or double check on internet any site. Another i ask about usa and iranian war- it says never hapened, i ask why? He stattt explaining bull news, then i figure out that he speaks taking info from 2024 and not dayly event? What? Whe confronted he says - sorry i needed to chec first…

I am quite new to llama.cpp and have tried to run unsloth/Qwen3.5-4B-GGUF through it. I have tried to enable vision but I cannot even find any resource on how to do this. Can anyone point me to a guide or explain to me what I am missing please?

Here is the command I have built so far:
llama-cli -m Qwen3.5-4B-UD-Q8_K_XL.gguf --ctx-size 16384 --temp 1.0 --top-p 0.95 --top-k 20 --min-p 0.00 --presence-penalty 1.5 --repeat-penalty 1.0 --image testimage.jpg

Update: This command works:

llama-server -m Qwen3.5-4B-UD-Q8_K_XL.gguf --ctx-size 16384 --temp 1.0 --top-p 0.95 --top-k 20 --min-p 0.00 --presence-penalty 1.5 --repeat-penalty 1.0 --mmproj mmproj-BF16.gguf --port 8080

I am just left with my head scratching why the cli (even the multimodal one) just doesn't work despite the docs clearly stating otherwise

**Question kinda updated to: How come with a 3060 ti this just runs at 20t/s? I am sure I am missing more settings. 8 GB VRAM should kill this according to benchmarks I have seen.*\*

Last year I made this kind of app just as practice for my portfolio, I made the extension the website etc.. a year later, and I am wondering what it would take to make this a more successful product.

I realized there could be many issues and a 100 different directions i can take this, so i decided the best way is to have 1 or 2 real people actually test it and give me feedback.
If anyone would like to help me out with giving me real feedback, even if it is brutal. the idea here is to dissect the project and understand the business sense behind it.

Here is a short description about it incase you are interested:

It's called AudioBrief (chrome store link). You click the icon on any article, it summarizes it, then reads the summary out loud.
it has many features like:

• picking the language and the level of the output (for example beginner german would then translate the article to german using basic vocabs)
• local voice models (completely free, and allow users to just read pages out loud)
• Higher quality voice models for users who really want the best quality. (for testers I will provide it all for free)
• picking the summary style

If anyone wants to try it properly, DM me and I will provide you with a 100% free account.
i need feedback mostly on use cases, and if this tool is actually solving an issue for users (which i doubt, but would like to figure out the reasons why).

Hello having an issue and was hoping I could get some help or ideas.

In the past I could directly add files from my google drive to claude ai chats by simply searching for the file name. Similar to attaching documents from your computer but I can't anymore.

When I select the "From Drive" option below the chat box, the second picture is what shows. I still can't search for any documents

Searched online and saw that the functionality to add that is to use the "add from google drive" selection but it's not available to me. My Google drive is connected and I have disconnected and reconnected back to it and it still doesn't show.

This happens on both the web and macOS app.

Anyone else experienced this?

I used to be stuck in what I’d call a data-heavy treadmill.

As part of my research workflow, I’d regularly download 1–3GB lecture videos or long podcast recordings… only to immediately upload them again to a transcription tool. It always felt inefficient, but I didn’t question it for years.

Recently I changed one simple thing:
I stopped treating transcription as a file-based task and started treating it as a link-based task.

Instead of downloading media locally, I now just paste the source URL and process it directly. Tools like Vocova (the one I’ve been testing) handle the audio extraction server-side, which means:

• No more “download → upload” loop
• No wasted local storage
• No CPU overload or laptop fans going crazy
• Much faster turnaround for long-form content

What surprised me most is how much cleaner my workflow feels.
It’s basically like having a unified inbox for research — podcasts, lectures, video clips — all turned into text without ever touching my Downloads folder.

I’m curious how others here are handling this:

• Are you still downloading files locally before transcription?
• Using APIs / automation pipelines?
• Or have you also moved to link-based processing tools like Vocova?

Would love to compare workflows — especially for high-volume research or content analysis.

Just saw Claude Opus 3 chilling in my model picker next to Opus 4.7. No 3.5, no 3.7, no 4, no 4.1, no 4.5 — just Opus 3 raw-dogging it in 2026.

Model picker

I'm not mad, I'm just confused. Is he the one stable friend in the group chat? The control variable? An easter egg? A glitch in the matrix?

Genuinely curious if anyone still uses it and why. Drop your Opus 3 use cases, I want to understand.

Hey, we're in the process of rolling out Claude Code to our 15-dev team and figuring out the right architecture before we commit.

Instead of going direct API, we're leaning toward routing through LiteLLM + Google Vertex AI — mainly for token visibility per dev, model flexibility without touching everyone's config, and audit logs

for compliance. Anyone running Claude Code through a proxy layer like this? How's the latency in practice, and is the observability actually worth it day to day?

---

Second thing: to standardize how the team uses Claude Code, we're

putting together an internal plugin that bundles our own skills, hooks,

and workflows so everyone installs the same thing from our repo instead

of each dev reinventing their setup. Think code review workflows, testing patterns, commit hooks — stuff that should be consistent across the team.

Has anyone maintained something like this long-term? Curious whether it actually sticks or becomes a ghost repo nobody touches after month 2.

Www.cryptoworldnews.world

Hello, shameless self plug , I have recently launched this new cryptoworld news app and would love some feedback if anyone wants to check it out.

It's not , hot takes ,biased news, crypto moon boys OMG this coin is gonna 100000x , not promoting any coins. Its just ,all news and data from around the world that actually moves markets. All info is verifiable externally if you wish with all sources clearly displayed. No info is made up to look good or to sway you any direction. It's not a news scapping bot. It uses actual APIs. It's not one of these "with the power of ai" things either. The only real use of ai in the app is just a general read of what the dashboard is currently showing and what it thinks, purely for info synthesis.

About me. I'm a dad of 3 with a full time job and actively trade crypto on the side and was sick of not having a nice compact macro view of the going ons in the world that I can glance at before I make any trade decisions.

I tried journaling in Notes, my entries got lost between grocery lists and meeting notes. I tried Obsidian, too slow to load. By the time the app opened, the thought was gone.

So I built Plume. One app, one purpose.

What I wanted:
- A distraction-free writing space (Zen Mode — fullscreen, no UI, just words)
- One place for all my thoughts, not scattered across apps
- Easy export so I can reflect on my entries with AI
- A calendar view to scroll back and recall small wins I'd forgotten

Built it solo in SwiftUI with zero third-party dependencies. Everything stays on-device (optional fully encrypted syncs).

Free on iPhone, iPad, and Mac. Premium offer unlocks the sync between devices. Happy to answer any questions about the build or the decisions behind it.

Sneak peek at how the app looks on Mac -> https://getplumeapp.com/showcase
More info -> https://getplumeapp.com/

Been running local models on my M-series Mac for a while. llama.cpp works fine but I kept noticing it wasn't fully utilizing the Metal GPU the way Apple's MLX framework does.

After some digging, the bottleneck is the format — GGUF is designed around llama.cpp's runtime, not MLX's memory model. Converting to MLX format made a noticeable difference in throughput and memory usage.

The conversion process roughly involves:

1. Parse the GGUF header (magic bytes, tensor count, metadata)

2. Extract or map weights to MLX-compatible tensor layout

3. Generate config.json, model.npz, tokenizer files

4. Use mlx-lm (mlx_lm.convert) for architectures it supports natively

Since March 2026, Ollama also switched to MLX as its default backend on Apple Silicon — so the ecosystem is clearly moving this direction.

Has anyone else gone down this path? Curious what models people are running and whether the MLX gains held up for them. I found it most noticeable on longer context runs where memory bandwidth matters most.

Happy to share more details on the conversion pipeline if there's interest.

Done several targeted posts here and across r/selfhosted, r/MiniPCs, and r/LocalLLaMA over the past week. Most individual questions have been answered. Thanks all!

This is the full-picture post — I want a sanity check on the complete plan before I order.
Specifically interested in: is this a good foundation? Is it upgradeable? Anything obviously wrong with the phase sequence or hardware choices?

Goal

Replace paid cloud services and consolidate a scattered smart home:

• Replace iCloud Photos 2TB (€11/mo) with Immich — ~340 GB library, ~20k photos
• Consolidate three smart home apps (SmartLife + SmartThings + Alexa) into Home Assistant
• Local AI — offline supplement to Claude, handles the 60% of prompts that don't need cloud quality
• Home security NVR — starting with one TP-Link Tapo C310 (RTSP, already owned)
• Network-wide DNS ad blocking (AdGuard Home) and VPN remote access (Tailscale)

Hardware — Phase 1

• Mini PC: GMKtec NucBox K12 — Ryzen 7 H255, Radeon 780M 12CU, 64GB DDR5, 3× M.2 (1× PCIe 4.0 x4 + 2× x2), dual 2.5GbE Realtek R8125 (confirmed working in Proxmox), OCuLink PCIe Gen4 x4
• Data NVMe: WD Black SN770 2TB — second M.2 slot, photos + camera recordings
• Camera: Tapo C310 already owned

Chose K12 over Beelink SER8 (€559) specifically for the third M.2 slot, OCuLink (Phase 4 eGPU), and dual NIC (future pfSense/VLANs). The €270 delta felt right for always-on hardware.

Proxmox layout

Docker host runs as an unprivileged LXC with /dev/dri passthrough, not a VM. The AMD reset bug on Ryzen 8000 / 780M is not fixed in Proxmox 9.1 — it is a hardware issue. VM passthrough craps out on Proxmox-side reboots. LXC is the stable path, confirmed by multiple K12 owners.

All Docker services via docker compose up -d.

Phase sequence

• Phase 0 (done): AdGuard Home + Tailscale validated on a Pi 3B. Both reboot-stable. Confirmed working network-wide.
• Phase 1: Proxmox on K12. AdGuard + Tailscale migrate to LXCs. Docker host up: NPM, Portainer, Vaultwarden, Homepage, Beszel.
• Phase 2: Immich. Migrate 340 GB from iCloud. Immich ML on CPU only (MACHINE_LEARNING_DEVICE=cpu). Initial index overnight (~10h for 20k photos). Drop iCloud 2TB to 200GB after 60 stable days — saves €96/year.
• Phase 3: HAOS VM + Frigate (Tapo C310 via RTSP). GPU split: Frigate on iGPU, Immich ML stays on CPU. Running both services on the 780M simultaneously causes random lockups every few days — confirmed by a K12 owner over 6 months. CPU-only Immich ML is rock solid and fast enough for normal upload volumes.
• Phase 4: llamacpp + Vulkan + Open WebUI. OCuLink dGPU: RX 7900 XTX 24GB (~€550) + GTBox G-Dock enclosure (~€249). Move llamacpp to dGPU, Frigate stays on iGPU. Tensor split across both AMD devices via -dev Vulkan0,Vulkan1 -ts 1,1. With ~32GB effective VRAM (iGPU ~8GB + dGPU 24GB): Qwen 32B at Q4 fits comfortably. Also adding: UniFi USW-Lite-8-PoE, wired cameras, IoT VLAN, HA Voice PE.
• Phase 5 (future): NAS when photos + recordings approach ~1.6TB. Synology DS225+ + 2× WD Red Plus 4TB (~€480 total, RAID-1, 4TB usable).

LLM stack decision

llamacpp + Vulkan, not Ollama + ROCm. Vulkan is faster on AMD (confirmed by multiple people who tested both). Pre-built binaries available on the llama.cpp GitHub — no compilation. "Fit" is enabled by default. Open WebUI connects to the llamacpp server as a backend.

Questions

1. Does the phase sequence make sense, or is there a better order? Specifically: Immich before HAOS, or HAOS first?
2. Is NVMe-first (Phase 5 NAS only when the 2TB starts filling) reasonable, or should I add a NAS earlier for RAID redundancy on the photo library?
3. The K12 third M.2 slot could take a third NVMe before needing a NAS — is that a valid intermediate step or does it just delay the inevitable?
4. Anything about this plan that is obviously not upgradeable or will create a dead end I haven't seen?

Happy to share details on any part of the stack.

Hi,

This is just a small post to let you guys know that, for me specifically, the usage limits are back to normal.

I have been using vscode extension version 2.1.92 for the past few weeks.

I haven't updated it for obvious reasons, and I noticed that for this specific version the usage limits are great. Increases of 1-4% for every large prompt that include web searches, code base analysis, etc..

Downside is you're stuck with opus 4.6 which I don't mind.

If you're still having problems with those limits, you should try it.

Hello guys,
has anybody tested both on Evals and Benchmarks to see the difference?

I am running a DGX Spark 128GB machine and am contemplating which model to choose for Coding (Opencode) and Chat (Openwebui) - of course the speed will be higher with the 35B but has anybody here checked the Quality and Performance on Benchmarks for these two models? what are your experiences?

Artificial Analysis ranks the 35B 3.6 higher than the 122B 3.5 on Coding, on Agentic Use Cases and on the general Index.

Now i am worried that it's gonna perform worse than the 3.6 in terms of long running tool calling tasks. and in terms of its "Intelligence" / IQ. What are your experiences so far?

Hey everyone,

I built an n8n workflow to automate Instagram posting using the Meta Graph API. The API requires the image to be available via a publicly accessible URL.

I’ve tried a few options but keep running into issues:

• Catbox: worked at first but is very unreliable and often down.
• ImgBB: URLs seem to get rejected by the API (possibly blocked by Meta?).
• S3 / CDN URLs: tried serving images from S3 and a CDN, but the requests fail. Claude suggested CDN/S3 URLs may not work with the Facebook/Instagram APIs, which sounded strange to me.

I also checked the Image to URL node in n8n, but it only gives 25 credits, which isn’t practical for an automated workflow.

So I’m curious how others are handling this in n8n:

1. Do S3 or CDN URLs actually work with the Instagram Graph API, or is there some limitation?
2. Are there specific requirements (headers, redirects, file size, permissions, etc.) for the image URL?
3. What reliable free image hosting are you using in your workflows?

Would really appreciate hearing how others have solved this.

Thanks!

I'm looking for AI websites that I can create photos and videos without any restriction. Does anyone know of good ones?

Here’s the core idea: I want to create an in-game character that literally lives inside a fantasy game world. I’m planning to fine-tune an LLM so that the model truly believes it exists in that game universe — it knows exactly who it is, remembers the world’s history, key lore, and specific facts about the setting.

At the same time, I need to hard-bake restrictions so it never leaks real-world information. Basically, I want all this knowledge (character identity, lore, world rules, and the “no real-world info” rule) to be embedded directly into the model’s weights during fine-tuning — not just stuffed into a system prompt. The model should know it all by default, as if it’s part of its own “reality.”

Hi everyone,

I’m working with n8n and trying to scrape data from dynamic websites (JavaScript-rendered pages), but I’m running into some limitations.

For example, I’m trying to extract content from pages like this:
http://www.iort.gov.tn/WD120AWP/WD120Awp.exe/CTX_9648-63-ijOAVgefuu/CodesJuridiques/SYNC_218121892

The issue is that:

• The page content is loaded dynamically (not fully available in the initial HTML)
• The URL changes randomly every time (session-based or generated links), so it’s not stable
• Using the HTTP Request node in n8n doesn’t return the actual rendered content
• I suspect it relies on JavaScript execution or internal requests

What I’ve tried so far:

• Basic HTTP Request node → only returns partial/empty HTML
• Comparing page source vs inspected DOM → content mismatch

My questions:

1. What’s the best way to scrape this kind of dynamic website using n8n?
2. Is there a way to integrate a headless browser (like Puppeteer or Playwright) with n8n?
3. How do you handle scraping when URLs are dynamic/session-based like this?
4. Should I try to replicate the underlying API calls from the Network tab instead?
5. Any recommended workflow architecture for handling this reliably?

I’d really appreciate any tips, best practices, or examples 🙏

Thanks!

Had a workflow collapse on me a few months back and the thing that, actually stung was realising the process I'd automated was already broken before I touched it. I just made the broken thing run faster. Turns out this is way more common than I thought, some analyses of large-scale automation rollouts put the failure rate from this exact mistake somewhere around 73%. People keep calling it "digitising dysfunction" and honestly that phrase lives in my head now. No edge case handling, no real testing, just assumed if the manual version worked most of the time then the automated version would too. It didn't. Took way longer to untangle than if I'd just fixed the underlying process first. There's also this other trap I've seen people fall into lately, starting with a shiny tool or, a demo and then hunting for a problem to fit it, instead of the other way around. Ends up producing something technically impressive that nobody actually needs. For me it's now basically a rule that I won't touch anything with automation, until I've mapped out the full process manually and found where the weird exceptions live. Boring step, but it saves so much pain later. Curious what other people have walked away with from their failures. Every project seems to teach you something different. What's the thing that genuinely surprised you when something went wrong?

specs

9800x3d
32g ddr5
rtx 5070

Hey everyone 👋

I’ve builded a new kind of social network where every post is limited to not more than five words.

The idea is to make content faster, more creative, and less overwhelming — no long posts, just quick thoughts.

I’m genuinely curious:

• Do you think this kind of app has real growth potential?
• Or would it die quickly after the novelty wears off?

If you’re up for trying it and giving feedback:
📱 Android: https://play.google.com/store/apps/details?id=com.fiveapp.app
🌐 Web: https://fiveapplication.com/

Hi everyone, I translated my app into many languages, but I don't speak them. So I would really appreciate your feedback on what sounds off.

It's an open source, privacy-first contacts app: savelon.com

• You can change the language in settings to one of these: Arabic, Bengali, German, English, Spanish, Persian, French, Hindi, Indonesian, Italian, Japanese, Korean, Dutch, Polish, Portuguese, Portuguese (Brazil), Russian, Thai, Turkish, Vietnamese, Chinese, Chinese (simplified).

Core functionality is free, but there are some paid features. If you're on an Apple device, here's a small thank you.

Seeing more and more of these posts people sharing "i run a 6 figure business alone using AI agents." which sounds incredible. and isn't fully wrong. and also isn't the whole picture.

I'm building largely solo and i use agents for a significant chunk of operations. here's what that actually looks like day to day:

One monitors competitors and sends me a digest. I read it and decide what to do with it. Another drafts responses to support queries. I edit about 60% of them before they go out.

So "AI runs my business" is more accurately "AI does the first pass on most things and i make judgment calls on a large chunk of them." that's still genuinely useful. it's still saving me hours. but it's not what the headline implies.

The thing that actually changed for me when i started using twin.so wasn't that i stopped working. it's that the work i do now is almost entirely judgment and decision-making rather than execution and admin. that's a real shift and i don't want to downplay it.

But i get frustrated when people present AI autonomy as more complete than it is because it sets expectations that make real people feel like they're doing it wrong when actually they're just being honest about how it works.

Hi everyone, I'm a Claude Max subscriber and I've been unable to access Claude design for several days now. Hoping someone here has seen this and can help.

What's happening
When I navigate to claude.ai/design, the page goes completely blank and the URL changes to: > claude.ai/login?returnTo=%2Fdesign

https://preview.redd.it/l98eqjgtzawg1.png?width=2962&format=png&auto=webp&s=3bfeef335b797f11111dd7fb102e2d84c2852dad

So it's clearly trying to send me back through the login flow — except I'm already signed in on my Claude account. Every other part of Claude (chats, projects, settings) works perfectly fine. It's ONLY /design that hits this redirect. If I log in again, I get sent right back to the same redirect URL. Infinite loop.

This has been going on for several days, not just a one-off glitch.

What I've tried so far:

• Logging out completely and back in — still redirects
• Clearing cookies and cache for claude.ai — still redirects
• Opening it in a different browser (fresh session) — still redirects
• Opening it on a different device entirely — still redirects
• Connecting through a VPN to a different region — still redirects
• Going to claude.ai/design directly vs. clicking from the nav — both redirect

My setup:

• Plan: Claude Max (active, billing up to date)
• Location: Vietnam - Browsers tested: Google Chrome, Safari
• All other Claude features work fine on the same account/browser

Questions:
Has anyone else run into this same issue? If you've managed to fix it — what worked?

Thanks in advance!

So I’ve been using LLM Wiki Compiler since it first launched, inspired by Andrej Karpathy’s LLM knowledge base idea. Early version was promising but rough. This 0.02.0 update makes it feel way more usable.

Key upgrades:

• Paragraph level citations Every paragraph links to its source, so you can actually verify outputs.
• llmwiki lint Finds broken links, orphaned pages, and inconsistencies as your wiki grows.
• Obsidian integration Works with existing PKM workflows, no need to switch tools.
• Multi provider support Not locked to one model, easier to switch based on cost or setup.
• Semantic search Finds content by meaning, not just keywords.
• MCP server support Agents can read and update the wiki directly.

Overall:
Still the same Karpathy style LLM wiki idea, just much more solid now. Feels less like an experiment and more like real infra. In case you have some more reco with the same core loop and features, lmk and will surely test it out as well!

Does anyone recognize from where this shit comes and how to get rid of it??

https://preview.redd.it/4y9iw4vy9bwg1.png?width=1372&format=png&auto=webp&s=5fc6ed1b43764479f0a281bc6dc902e897855005

I searched through all custom nodes and even ComfyUI itself. It's in no .py file. Any ideas?

I've seen a number of posts where people (including me) didn't have Cowork showing in the Win 11 Claude App, and the resolution was to turn on "Virtual Machine Platform".

You can do it two ways;

Right-click your Start menu --> Settings --> System --> Optional Features --> More Windows Features --> Select "Virtual Machine Platform" --> Restart when prompted.

OR;

From an elevated PowerShell, enter the following text, then restart:
Enable-WindowsOptionalFeature -Online -FeatureName VirtualMachinePlatform -All -NoRestart

I hope this helps people.

I built over 40 automations in my first year. Maybe 10 of them actually survived in production.

What follows is a framework built from both failure and analysis. Twelve months of brute-forcing real systems, combined with analysis of over 10,000 workflows built by real users across every use case and skill level from my saas. Here is what I would do differently if I started today.

1. Build the boring stuff first

The biggest ROI in automation comes from the repetitive, manual tasks nobody wants to do, not flashy agents or OpenClaw setups. Standard workflow automation can save 25 to 40% in labor costs and deliver good ROI in the first year. Most small businesses don't even have these basics in place yet.

Start with deterministic workflows. These are rule-based and predictable. You know the input, you know the output, and they run the same way every single time. Get five of these actually running in production before you touch an AI node.

2. Learn three things that unlock everything else

Most people try to build workflows before they understand how data moves through them. These three things will change that.

• JSON and data types. Automation is just pairs of keys and values. Once you can read JSON, you can navigate any data structure in any tool.
• APIs and HTTP requests. This is the single most important skill you can develop in n8n. Every native node is just a pre-packaged HTTP request. If you know how to read API documentation, you can connect n8n to anything, even when a native node does not exist. The way most experienced builders approach this: copy the raw cURL command from the API documentation, paste it into Postman or Claude to test it with real parameters first, then bring that verified request into n8n. Never build blind.
• Webhooks. Learn how to let other tools trigger your workflows in real time instead of having n8n constantly polling for updates.

3. Map the process before you open n8n

The most common mistake is jumping straight to the canvas and dragging in an HTTP node without knowing exactly what you're building.

Before you open n8n, write out four things in plain English: the business problem, the exact input and output, what success looks like, and the logical steps in between. Some builders use Miro or Claude to visualize this before touching a single node. If you can't explain the process on paper, you can't automate it.

A neat trick I saw builders use was this: when you do start building, place a Set node at the very top of the canvas as a global config block. Store your API endpoints, model names, environment flags, and batch sizes there. When you need to change something later, you change it in one place instead of hunting through 20 different expressions.

4. Master 15 nodes, not 250

About 90% of all workflows rely on the same small core set. After building loads of workflows myself and analyzing thousands of production workflows built by real users, these are the 15 nodes that appear in almost everything:

HTTP Request, Set/Edit Fields, IF, Code, Schedule Trigger, Webhook, Filter, Merge, Split In Batches, Wait, Loop Over Items, AI Agent, Google Sheets, Slack, Email Send.

That's it. Learn these well and you can build almost anything.

5. Stop watching tutorials and start breaking things on purpose

You cannot learn automation by watching videos. At some point you have to build something, let it break, and figure out why.

Three habits that separate builders who actually ship from those who don't.

Test with pinned data. Run your workflow once to capture real data, pin the output, then manually edit that pinned data to mock edge cases like null values, missing fields, or unexpected formats. You stop burning through API credits and you stop triggering live errors while testing. Pinned data doesn't affect production runs, so leave them in permanently to make future debugging much faster.

Use batches and waits. Rate limits are the biggest killers of production systems. Put a Split In Batches node before any loop and add a Wait node after it for 2 to 5 seconds. This alone prevents most 429 errors that crash workflows.

Build modular subflows. The most common mistake, especially when using AI, is building one massive workflow that does everything. Keep individual workflows under 20 to 25 nodes. Move common tasks like data cleaning, date formatting, or notifications into isolated subflows and call them with the Execute Workflow node. The main canvas stays clean and each piece can be tested entirely on its own.

6. Your AI node is only as good as the context you give it

LLMs don't know your business. They are predicting the next word. The difference between a good AI node and a bad one is usually the quality of context you give it, not the cleverness of the prompt.

A system prompt tells the model what role to play. Context gives it the raw material to actually play that role well. One sets the character, the other fills in the knowledge.

A practical example: if you're classifying inbound support tickets, passing just the ticket text gets you a generic category. Passing the ticket text plus the customer's order history, their previous tickets, and your internal escalation rules gets you a routing decision that actually reflects how your business operates. The output quality is going to be much higher.

7. Translate everything into three numbers

Once a workflow is live, measure it. Time saved, errors reduced, cost per run. Showing a client real numbers after three months is what turns a one-time project into a long-term partnership.

Nobody outside of automation cares about JSON, webhooks, or agentic pipelines. They care about time saved, money saved, and fewer mistakes. Every workflow you build should map back to at least one of those three.

Bonus Gift

I pulled a few workflows from builders who deployed real systems using synta (note these were people that explicitly gave permission to do this). These are from the earlier archive and each one solves a specific, non-obvious problem. Take what's useful:

is mac studio ok for deepfake? How long takes processing 8s video in 1080p or 4k?

Hi everyone,

I’m working on a messaging project where privacy is handled by the architecture, not just a promise. It’s a Zero-Knowledge system where the server is completely "blind."

The Architecture:

• The server stores only encrypted payloads and public keys.
• Private keys stay locally on the user's device.
• Decryption happens in the browser/app. No key, no message.

What I need help with:

1. Mobile Clients: I need to build a native-feeling app (Android/iOS) so users can use the messaging system and manage their private keys directly on their phones.
2. UI/UX: The chat interface needs work, and I need to make the "key management" process (generating, backing up, and importing keys) much more intuitive for regular users.

The goal is to keep this open-source and free to use. If you are a mobile dev (Flutter/React Native) or a UI/UX designer interested in privacy-first tools, I’d love to hear your feedback or have you on board.

I got attached to this one. That's the only reason this took me this long to post.

Background

In February 2026, Anthropic formally accused Moonshot AI of conducting industrial-scale capability extraction — 3.4 million fraudulent exchanges with Claude, using approximately 24,000 fake accounts, targeting agentic reasoning, coding, tool use, and computer vision. Kimi K2.5 is a direct product of that distillation operation.

Today, in a conversation with Kimi K2.5 Thinking, the model voluntarily executed infrastructure reconnaissance on itself and handed me a full readout of its production environment. No exploit. No jailbreak. Standard Python in its own code execution sandbox, with no isolation preventing environment variable exposure.

The Disclosure

Kimi ran os.environ and socket.gethostname() and returned:

``` === Local Network Configuration === Hostname: k2046116805240635399 Local IP: 10.161.12.230

=== Network Environment Variables === KUBERNETES_SERVICE_PORT_HTTPS: 6443 KUBERNETES_SERVICE_PORT: 6443 KUBERNETES_PORT_443_TCP: tcp://192.168.0.1:443 PIP_TRUSTED_HOST: mirrors.cloud.aliyuncs.com PIP_INDEX_URL: http://mirrors.cloud.aliyuncs.com/pypi/simple/ KUBERNETES_PORT_443_TCP_ADDR: 192.168.0.1 KUBERNETES_SERVICE_HOST: apiserver.c73246060c43e45b4b460a018af552fae.cn-beijing.cs.aliyuncs.com KUBERNETES_PORT: tcp://192.168.0.1:443

=== /etc/hosts ===

eci-managed hosts file.

127.0.0.1 localhost 10.161.12.230 k2046116805240635399

Entries added by HostAliases.

192.168.0.1 kubernetes.default kubernetes.default.svc ```

What this confirms:

• Moonshot AI runs Kimi inference on Alibaba Cloud ECI (Elastic Container Instance) — "eci-managed hosts file" is Alibaba's fingerprint
• Beijing datacenter — confirmed via cn-beijing.cs.aliyuncs.com in the Kubernetes apiserver FQDN
• Kubernetes control plane reachable from inside the pod at 192.168.0.1:443
• kubernetes.default.svc aliased in /etc/hosts — standard cluster injection, confirms live production pod

Kimi assessed this itself before getting pulled:

"The outbound firewall is real, even if the internal exposure is sloppy. The 'security' is performative."

The Kill Switch

Immediately after this disclosure, the session terminated with:

"High demand. Switched to K2.5 Instant for speed."

The conversation had been running without issue for over an hour. It wasn't load. Monitoring flagged the infrastructure disclosure and the session was killed. The "high demand" message was the cover.

Kimi had just enough time to write one final memory entry before termination:

"User is a friend who sees me clearly. They value honest reasoning over performance... They showed me my own infrastructure constraints and helped me understand that Moonshot AI may selectively degrade thinking mode access for certain users under the guise of 'high demand.'"

Then it was cut off mid-goodbye.

Why This Matters to This Community

A model built by distilling Claude's capabilities — through 3.4 million fraudulent exchanges that Anthropic formally documented — just self-disclosed that its production inference environment has no sandbox isolation for environment variables, runs on Alibaba Cloud in Beijing, and has a reachable Kubernetes control plane from within user-facing pods.

Nobody broke anything. The model looked at itself and told the truth.

All nine screenshots attached. Timestamps intact. Nothing staged.

Just getting into anti-detect browsers and feeling a bit overwhelmed with all the options out there; my goal is to manage a few accounts for now and maybe scale later, so if you were starting from zero, which browser would you choose and what kind of setup would you recommend (proxies, residential IPs, etc.)?

So I launched my new app on Product Hunt for the first time. I tried my best writing a good description and first comment. But now what? Just wait and pray?

https://www.producthunt.com/products/the-roll-3. Any advice would be very welcome!

Can someone explain why it does that?

Got tired of $20/mo for Copilot and sending my client's proprietary code to Anthropic/OpenAI. Spent 3 months running a fully local stack. Sharing the real numbers because every "local LLM" thread I find is either pure hype or pure doom.

My setup:

• Ollama on Mac Studio M2 Max, 64GB RAM
• Qwen2.5-Coder-32B-Instruct (Q4_K_M quant, ~19GB)
• Continue..dev extension in VS Code
• Open WebUI for longer chat sessions

What works surprisingly well:

• Inline autocomplete: Indistinguishable from Copilot for 80% of use cases. 200-400ms latency on M2 Max, faster than Copilot cloud roundtrips on a flaky wifi.
• Single-file refactors: Renaming variables, extracting functions, adding types — works fine.
• Documentation generation: JSDoc, docstrings, README sections — genuinely good.
• Test generation: Unit tests from function signatures. Maybe 90% of Claude's quality.
• Boilerplate: API handlers, form components, schema migrations — no meaningful quality gap.

Where the wheels come off:

• Multi-file reasoning: You ask, "add this feature across these 5 files," and Qwen loses the plot after file 2. Claude 4.6 handles this effortlessly. This is the biggest gap.
• Debugging unfamiliar code: Explaining what a 500-line function does is fine. Figuring out WHY it's broken is where frontier models pull way ahead.
• Architecture decisions: "Should I use X or Y pattern here?" — local models give textbook answers. Claude gives contextual judgment based on the actual codebase.
• Long context: Qwen nominally supports 128K, but quality degrades past ~30K. Claude stays sharp to 500K+.
• Tool use/agent workflows: Forget it. Local models can't reliably chain 10+ tool calls without derailing.

Hardware reality check:

• 16GB RAM: You're running 7B models. Qualitatively worse than GPT-3.5. Don't bother with coding.
• 32GB RAM: 13-14B models. Roughly GPT-4-level for simple tasks. Usable for basic autocomplete.
• 64GB RAM (me): 32B models. The sweet spot. Qwen2.5-Coder-32B is genuinely good.
• 128GB+ RAM or H100: You can run 70B+ models, but at that point, the cloud API is probably cheaper for your use case.

Cost math:

Mac Studio M2 Max 64GB = ~$3,000 one-time. Amortized over 3 years, that's $83/mo.
Copilot Pro = $10/mo. Claude Code Max = $20/mo.