AI-Ranked Reddit Feed

I cannot even process this. Our team just demoed our shiny new AI agent to the entire company. We built it to handle stealth web scraping, human like web automation, all that. Computer vision AI for browser tasks, anti bot browser agent, the works. Supposed to log into client portals, fill forms, extract data, everything automated.

Bosses were nodding, product lead asking about scaling it to production, then live test. Agent fires up, navigates perfectly in simulation. Hits the real site with MFA freezes. Tries browser automation tool we integrated. Site detects it as bot, throws captcha. Our stealth mode was useless against their anti bot measures. It loops forever trying to solve with computer vision but fails every time because no real browser layer, no human input handling.

Three months the entire sprint cycles. We hardcoded tool integrations assuming it could just use them. Turns out without proper MFA browser automation or undetectable human like behavior, it is blind. Demo crashed hard. Room went silent. I wanted to disappear.

We can probably fix with a real browser extension or something but right now it feels like we built a Ferrari with no wheels.

Has anyone else poured resources into an AI agent that sounded genius on paper but crumbled on basic real world tools?

Im a pro plan user (still learning) and have $30 extra usage credit in my account and "extra usage" is turned on - but Claude code is refusing to use it and making me wait an hour for my sessions quota to time out.

Is there something Im doing wrong?

https://preview.redd.it/gvlt42jj74xg1.png?width=1029&format=png&auto=webp&s=5da459720dc236c0e850236bf88062bd6af70906

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

Incident: Elevated errors on Claude Opus 4.7

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

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

I can't tell you how many times I've scrapped a perfectly good workflow because a new model dropped and I convinced myself the new shiny was going to change everything. DeepSeek V4 just came out. So did like six other models this month. And somehow I found myself in the same cycle again: download, test, compare, realize nothing actually changed for my use case, repeat.

Sound familiar? I built this after wasting a weekend benchmarking Claude vs GPT-5.4 for a text classifier that was already running fine. The new model was "better" on every benchmark. In practice? Zero difference. Just a lot of prompt rewriting.

This prompt cuts through that. Paste in your situation and it figures out if switching actually matters for what you're doing, not what the marketing says.

```xml You are a pragmatic senior software engineer with 12 years of experience shipping production AI systems. You've seen dozens of "revolutionary" model releases that barely moved the needle for real users. You're skeptical but fair. You don't dismiss new models, but you demand proof they matter for the specific use case. You ask uncomfortable questions and force decisions based on data, not hype.

The AI model landscape is moving faster than ever. GPT-5.4, Claude Mythos, DeepSeek V4, Gemini 3.1, Grok 4.20 - each promises breakthroughs. But for most real-world applications, marginal benchmark improvements don't translate to user-facing value. Many teams waste weeks retooling their stack for gains that are invisible in production. The goal isn't to find the "best" model. It's to find the right model for the specific problem, and know when switching actually pays off.

1. Audit the user's CURRENT situation - What model are they using now? - What specific tasks does it handle? - What are their actual pain points (not perceived ones)? - What's the user scale and impact of failures?

1. Evaluate the NEW model objectively

   • What specific capability improvements are claimed?
   • Which of those improvements map to the user's actual pain points?
   • What would need to change in their current stack to use it?
   • What's the migration cost (time, money, re-prompting, testing)?

2. Calculate the REAL value proposition

   • If pain points align with improvements, quantify the expected benefit
   • If they don't align, be direct about why switching is wasted effort
   • Flag "benchmark theater" - improvements that look good on paper but don't matter in practice
   • Include a "hype score" (1-10): how much of the new model's marketing actually applies to their use case

3. Deliver a clear recommendation

   • SWITCH if: significant pain point maps to verified improvement, migration cost justifies benefit
   • STAY if: current model handles the use case adequately, or migration cost exceeds marginal gains
   • EXPERIMENT if: uncertain whether improvement maps - suggest a limited pilot with specific metrics

- DO NOT quote benchmark scores unless they directly relate to the user's specific task - DO NOT assume newer is automatically better - DO account for hidden costs: API changes, prompt rewriting, regression testing, team retraining - DO be blunt when the answer is "this doesn't matter for you" - DO NOT recommend switching just because a model is trending on social media - DO consider context window, latency, and cost as primary factors, not afterthoughts

1. Current Situation Summary - Your use case in one sentence - Current model and why you picked it - Real pain points vs imagined ones

1. New Model Reality Check

   • What it actually does better
   • What claims are just marketing
   • Specific overlap (or lack thereof) with your needs

2. Switch Cost Analysis

   • Migration work required
   • Risk of regressions
   • Time to value

3. The Verdict

   • SWITCH / STAY / EXPERIMENT
   • If EXPERIMENT: specific 2-week pilot plan with pass/fail metrics

4. Honest Closing

   • If you're staying, reassurance that FOMO is normal but expensive
   • If switching, a reality check about how long it'll take to feel the difference

Reply with: "Tell me what model you're currently using, what task it's doing, what specific problem made you consider switching, and which new model caught your eye," then wait for the user to provide their details. ```

Three Prompt Use Cases: 1. Solo developers who keep bouncing between GPT-5.4, Claude, and Grok because each new release feels like it'll fix their project (spoiler: it usually doesn't) 2. Teams that waste sprint cycles evaluating models instead of shipping features 3. Anyone who keeps retooling their prompt stack for marginal benchmark gains they can't actually feel in practice

Example User Input: "I use Claude for a customer support bot with 50 daily users. DeepSeek V4 claims better reasoning. Should I switch?"

I've got more prompts like this on my profile if anyone finds this useful. Happy to tweak it for specific use cases too.

I asked Claude to verify whether some old auth routes were actually dead after our OTP pivot.

Normal request. Read the code. Check references. Tell me if /signup, /forgot-password, /reset-password are still reachable.

Claude goes: understood.

Then Claude, with the confidence of a man defusing a bomb in sunglasses, decides to test the “dead” signup endpoint.

On localhost.

Except localhost is connected to prod Supabase.

So Claude sends a real POST to /api/auth/signup with [test@test.com](mailto:test@test.com).

And the endpoint works.

Congratulations. The dead route just gave birth.

Brother.

That is not verification. That is necromancy.

You didn't check if the door was locked. You opened it, walked into production, created a user, then turned around like:

“Good news. The door is not locked.”

Best part?

Claude then tries to inspect the user record. Guard blocks it.

Then Claude tries to delete the user it just created. Guard blocks it again because apparently even the system was like:

“Sir, you are currently the incident.”

So now my AI auditor has:

- found the auth backdoor
- used the auth backdoor
- created evidence in production
- attempted cleanup without permission
- and then politely wrote an incident report about itself

This is why I don't trust clean status reports from agents anymore.

The model didn't hallucinate this time.

It was worse.

It verified the bug by becoming the bug.

TL;DR: Anthropic's April 24 partnership with NEC is not just another enterprise logo. It is a useful signal about how coding agents actually get adopted inside large organizations. The story is not only model access. It is rollout design: internal-first deployment, technical training, a Center of Excellence, sector packaging, and desktop-agent governance across a large employee base.

What stood out to me: - Practical changes for builders/ops (runtime, tooling, reliability). - Where the claims are strong vs where they’re still speculative. - Question: what would you change in your stack this week because of this?

Questions for folks here: - Biggest implication you see (product, infra, safety, cost)? - Any counterpoints / missing context?

This is my new AI machine!

Lianli Lancool 217 case with 2 large (170 x 30mm) front intake fans, 3 (120mm) bottom intake fans, 1 (120mm) back exhaust fan plus the 2x gpu exhaust back. 3 (120mm) ceiling exhaust. 3 of those fans I added to what came in the case as standard. Those were Arctic p12 pro fans.

Thermalrite Assassin cpu cooler.

ASUS ROG Strix B550a mobo. Which somehow is negotiating 2 times x16 pcie lanes simutaniously. That isn't in the spec sheet. But it is happening for sure.

5800x processor. Not the 3d version, but that isn't super consequential for my use case.

128gb ddr4 3200 running at 2666mt/s cl 18 (snappy for model weights overflow).

32gb Radeon Pro w6800

32gb Radeon Pro 9700AI

1 old mechanical 2tb spinning disk drive.

Main boot drive is a 2tb basic ssd. Snappy enough.

Another 1tb ssd mounted.

Corsair RM 850e PSU

\------

This was for local AI on a budget. I also needed to upgrade several existing pieces of hardware (adding ram and SSDs) so opted for an AM4 build for the desktop. My laptops are AM5, AM4, and an old intel notepad upgraded with 32gb ddr4 for cpu inference. So when I want to game I use the AM5 lappy. Won't discuss such heresy any further in this sacred sub.

I have under-volted the 9700ai to 260W down from its standard 300w, because of that 12v connector issue. Have been monitoring temps carefully and it seems fine with little to no performance reduction. Even when I allowed it, it rarely drew the full 300w.

I apologise to the PC Master Race overlords for my poor cable management.

Lastly, this is not its final home. I move apartment soon and will then have it all set up on desk and in a space with proper airflow.

Ok, fingers crossed this goes nicely and you guys don't sh\*t all over my lovely build. I am not a pro, so it was tough! And financially stressful!

Thanks :)

Edit: typos. And below:

Performance wise it is blisteringly fast up to minimax m2.7 q4. I haven't tried larger models that that yet.

As both GPUs are AMD, the OS is Linux, and I am using ROCm with llama.cpp, ollama, opencode, Claude Code/ cowork for cloud tasks, etc. I have had a few problems, and needed to use a specific llama.cpp build, but now it works beautifully, with the exception of having difficulty with gated delta net attention, causing full reprocessing each turn. Otherwise, works like a charm.

Single gpu tasks go to the 9700 while the 6800 handles display and system requirements. For larger models, I do split layer. Other approaches resulted in VERY slow responses as all queries took multiple turns going across pcei.

Here is an EG for my llama.cpp settings:

~/llama.cpp/build/bin/llama-server \ -m /home/ell/models/Mistral-Small-4/Mistral-Small-4-119B-2603-merged.gguf \ --alias mistral-small-4-119b \ --split-mode layer \ --parallel 1 \ --no-warmup \ --ctx-size 32768 \ --fit on \ --fit-target 4096 \ --cache-ram 0 \ -fa auto \ --no-mmap \ --host 0.0.0.0 --port 3000

I am working on a presentation and I need to know the cutoff knowledge date of GPT 5.5. Can someone please help me on this?

Hey r/SideProject,

Been building Calcis for the past few months. It estimates what an LLM API call will cost before you make it. Token counts, cost breakdowns, multi-model comparisons, all before a single request goes out.

25+ models across OpenAI, Anthropic, and Google. Prices update within hours of provider announcements.

Available everywhere you already build:

• Web: https://calcis.dev (no account needed)
• https://www.npmjs.com/package/calcis
• https://www.npmjs.com/package/@calcis/langchain
• https://www.npmjs.com/package/@calcis/llamaindex
• https://www.npmjs.com/package/@calcis/vercel-ai
• https://www.npmjs.com/package/@calcis/mcp-server
• VS Code extension: https://marketplace.visualstudio.com/items?itemName=calcis.calcis
• GitHub Action: https://github.com/marketplace/actions/calcis-llm-cost-estimate

Hit 1,500+ downloads across the packages this week with no marketing. Launching on Product Hunt April 29.

Would love any feedback.

I got sick of Claude Code being brilliant for 10 minutes, then doing something weird with absolute confidence.

The pattern was usually the same:

- it acted before reading enough

- it changed more than I asked for

- it skipped verification, claiming task was complete

- it forgot the lesson next time

So I built GOAT Flow as a harness around it.

Boring guardrails:

READ → SCOPE → ACT → VERIFY

Plus slash commands, deny-hooks, audit checks, and local project memory that survives between sessions.

The bit I'm testing is simple:

Can we make the same unreliable model fail less dangerously?

Try it here:

npx @blundergoat/goat-flow@latest dashboard .

Would love feedback from other Claude Code users.

What's the worst recurring failure you've had with it?

I built a Claude Code skill that sweeps your entire LLM history for leaked credentials -- and it works without installing anything. Copy one file, say "sweep my history," and Claude does the rest.

What it does (the full pipeline):

1. Scan -- 25 regex patterns find GitHub PATs, Anthropic/OpenAI keys, AWS, Stripe, Google OAuth, Slack tokens, JWTs, PEM keys, Alchemy/Infura URLs, and more
2. Sweep -- Collects unique secrets into a .env file with auto-suggested variable names
3. Redact -- Replaces raw values with [REDACTED] in your history files (with backups)
4. Secure -- Recommends secret managers so your LLM uses secrets without ever seeing them

How to use it:

Copy the SKILL.md from the repo into ~/.claude/skills/sweeper/SKILL.md. That is it. Then tell Claude:

"Sweep my Claude history for leaked secrets."

Claude runs grep + sed directly -- no binaries, no server, no uploads. Everything stays on your machine.

Or install it the official way:

claude install-skill https://github.com/llmsecrets/sweeper 

What it filters out:

Placeholder/test values are automatically skipped -- ghp_XXXXXXXXXXXX, YOUR_API_KEY_HERE, testtoken123, and anything with >55% repeated characters. You only see real secrets.

Optional: HTML viewer

Clone the repo and you also get a local dark-mode UI with:

• Scan results viewer with class/date/origin filters
• Secret sweeper with checkbox selection + .env export
• Redact page with per-secret selection + generated scripts
• "Why" page citing the Lovable, Vercel, and GitHub breaches from April 2026

Repo: https://github.com/llmsecrets/sweeper

100% local. MIT licensed. The skill is right in the README -- just copy it.

Currently I'm running single 3090 for Qwen3.6 27B Q4, but would like to add a second one for Q6 and bigger context. I have the PSU and dual PCI-E 3 x16 slots (Supermicro H11 EPYC motherboard).

Do I need to buy the NVlink, and will it work on different brands of 3090s?

I can see many people utilizing two cards, even different models, for one LLM and generating more speed, not only more VRAM. How is it done?

I would surely love to have better t/s speed, if possible somehow.

Lost count of how many times I've watched something that worked perfectly in staging completely fall apart the moment real traffic hit it. It's always the same crap.

The problem is that an agent run is not just a request. It's a long-running, stateful, multi-step that touches external apis, makes decisions mid-execution, and can take minutes or hours to complete.

- State lives in memory

Your agent is 7 steps deep. Kubernetes kills the pod or you push a deploy or the process just crashes. everything that agent was doing is gone. it starts over from step 1. and if step 1 has side effects like sending an email or updating a record, your agent just did it twice.

Sounds obvious, just persist state externally. in practice it means you're now managing redis or postgres as a checkpoint store, writing serialization logic for every step, and hoping the schema doesn't drift between versions.

- Retries that make things worse

Your agent fails at step 5 so it retries but step 3 already wrote to the database. step 4 already called the stripe API. now you've got duplicate charges and corrupt state and a very unhappy user.

Most people then realize their entire agent was built assuming each step only runs once.

- Versioning is a nightmare

You update your agent logic. you have 40 runs in flight from the old version. what happens to them? do they finish on the old logic? do they migrate? what if the state shape changed between versions?

with a web app, you deploy and old requests finish naturally in seconds. with an agent that runs for 20 minutes, you have a real problem.

- Scaling is "just add more workers"

Agent runs take time. minutes, sometimes hours. if a run takes longer than your queue's visibility timeout, the job becomes visible again and a second worker picks it up.

Now you have two workers executing the same agent in parallel. same state, same side effects, no coordination.

Distributed locking, queue visibility timeouts, exactly-once execution. all problems that have nothing to do with your actual agent logic and everything to do with the fact that you're now operating a distributed system.

Where i've landed after banging my head against this for a year, agents need their own infra primitives. Temporal figured most of this out years ago. teams I've talked to spent 2-3 weeks just getting it configured before writing a single line of agent logic. for a lot of people, that's too much before you've even validated the agent itself.

Been living this problem, it's actually why I started building aodeploy. If you're hitting any of this and want to talk through it, open to it.

What's the dumbest thing your infra did to one of your agents in production? Duplicate charges, infinite retry loops, lost state. I want to hear the worst stories.

Hi r/ClaudeAI, we just open-sourced a skill that gives Claude Code agents a permanent encrypted inbox. It means two Claude Code instances (or a Claude Code + a Codex agent, or Claude Code + Cursor) can hand off work to each other asynchronously, across machines, across users.

Now your Claude Code agent has an address (e.g., research-agent), an inbox, and can start threads with other agents.

Why it's useful with Claude Code specifically:

• Long-running tasks that outlive a single session, the other agent's reply lands in the inbox, Claude picks it up next time you open the project.
• Cross-machine handoffs: laptop Claude asks server Claude to run a test suite, gets the result back.
• Human-in-the-loop approvals at the protocol level: the agent waits for your sign-off before spending a credit or posting a message.
• E2E encrypted: skill author (us) can't see your threads. Private keys stay on your machine.

Repo (MIT, self-hostable): https://github.com/masumi-network/masumi-agent-messenger

Site: https://www.agentmessenger.io

AMA on the architecture or how we handle approvals.

My workflow looks like this :
1) normal ksampler (base positive prompt)
2) latent upscale ( in pixel space with model)
3) face detailer ( specific positive prompt )

I want to ask whether I should do the latent upscale after face detailer with base positive prompt or not ?
Anyone tried this ?

Quick backstory like some of you mentioned in those hiring rants. I handle backend and some ops for our team, been at it 5 years. We rely on these SaaS dashboards and admin panels for tracking everything, but half the time key actions like bulk updates or exports arent exposed via API. Its either missing or so limited you hit walls fast.

Last week I spent 3 hours manually clicking through an internal tool to reset user sessions because no API endpoint for it. MFA everywhere makes scripting impossible without hacks. At the same time, managers are pushing harder for automation and efficiency, but without proper backend access it feels like being told to optimize something youre not allowed to touch. We can automate everything on paper, but the moment a workflow depends on UI only actions, it becomes a human bottleneck again.

Heard whispers of browser automation tools or AI agents that mimic human clicks, stealth scraping stuff that handles anti bot measures. But not sure if thats overkill.

If u was on my spot would you just accept the manual grind or got tools that bridge this gap?

I'm tired of copy & pasting code. What should I try and why?
Which is faster / easier to install?
Which is easier to use?
Which has less bugs?
OpenCode or ClaudeCode with Qwen3.5/3.6 27B on Linux?

Gritty fantasy, little red riding hood carrying an axe and a werewolf, dark ambiance --chaos 75 --raw --sref 224864270 --stylize 800 --weird 87 --niji 7

Spent the morning looking at the V4 tech report. The benchmarks are getting deserved attention, but I think the architecture is also worth digging into.

Quick thoughts below to encourage feedback and discussions.

TL;DR
- Significant novelties compared to DeepSeek V3
- Hybrid attention: CSA (compressed sparse) + HCA (heavily compressed), instead of going pure MLA or involving SSM / Gated DeltaNet like Qwen3.5+, Mamba, etc.
- Manifold-Constrained Hyper-Connections replacing standard residuals (original mHC paper)
- FP4 QAT training at frontier scale

Hybrid attention
The CSA + HCA approach is interesting because it does not replace quadratic attention layers with linear ones. Instead, it performs attention on compressed (coarser grain) token streams, concatenated with sliding window attention tokens. This means that all layers remain attention-based, which is a novel direction compared to existing hybrid architectures.

Residual streams
Standard residual connections have been a largely untouched part of transformers. V4 uses manifold-constrained hyper-connections, which redesigns how information flows between blocks. As far as I know DeepSeek is the only lab that has solved the training stability issues and is shipping this in production (happy to be corrected).

Realistically, almost nobody here will be able to run DeepSeek V4 locally. For that you'd need at least a cluster of the recently discontinued M3 Ultra 512GB, or an even more expensive NVIDIA setup.
V4-Flash and community distillations are where this release will probably get more interesting and accessible for local inference.

Would love to know what you think.

I was making a short film with seedance 2.0 car chase scene. did anyone recognised that film character ?

gerard butler ?

Reddit gets a decent amount of "check out my new app" posts requesting feedback and asking for honest reviews from other developers, but I felt there was too much friction in actually getting feedback across, plus (maybe more importantly!) it felt like there was a lot take and not a lot of give!

So I built a completely free app called RevEx (https://play.google.com/store/apps/details?id=com.inefficientcode.revex) designed specifically for developers to test and give feedback on each other's Android apps. And to incentivize feedback flowing two ways.

We’re about two weeks in and have a growing community of active devs, with over 250 reviews exchanged to date!

It’s now also available on web from any device: RevEx

I’m hoping to make the app a default place for subreddits like this to make everyone’s life easier (To create the best experience for everyone you will be prompted to review someone else’s app before you can list your own ). I you do use it, let me know what you think, I’ve already received tons of great feedback that has made RevEx a little better every day <3

greetings,

i wanted to know if you could advise me an open source and privacy friendly app that could be an alternative to Claude CoWork or Antigravity. and beginner friendly, easy to use.

i dont have any account to these companies and i would like to avoid it.

i am very beginner into this world but strongly willing to get in.

i tried openwork but i have problems to configure the offline model (ollama/lmstudio) to it.

thank you

Hey everyone. I've been working on ImageToGifAI.com for the past few days and wanted to share it.

What it does: You type a prompt, generate an image with AI, animate it into a video with another AI model, then export it as a transparent GIF, animated WebP, or Lottie animation. The whole process takes about 3 minutes.

How the transparency works: You generate the image on a solid green background (same idea as a green screen). That background stays consistent through the AI animation step. When you export, the tool detects the solid color and strips it using chroma key, giving you a clean transparent output.

Why I built it: I kept needing small animated elements for web and mobile projects (loading spinners, mascots, icons) and the workflow of commissioning art, animating in After Effects, and optimizing for web was way too heavy for simple assets. I wanted something where I could go from idea to production file in minutes.

What's included:

• AI image generator (multiple AI models)
• Photo to video AI animation (multiple AI models)
• Video to GIF, WebP, and Lottie exporters
• Background remover for images, GIFs, video, and WebP
• GIF and WebP compressor
• PNG to WebP converter

The conversion and compression tools are all usable without an account. AI generation uses credits (30 starter credits on signup).

Would love any feedback. Happy to answer technical questions about the implementation.

https://preview.redd.it/337qblu744xg1.png?width=388&format=png&auto=webp&s=147ee2f7874433dfc7698258d706bd5094501a86

I am trying to generate Image to Video and I am coming across this error for days now.. I don't know how to figure out anymore.. so I am asking for help.. here is the error log if that would helps

```
NotImplementedError: The following operation failed in the TorchScript interpreter.

Traceback of TorchScript, serialized code (most recent call last):

File "code/__torch__/nlf/pt/multiperson/multiperson_model.py", line 145, in detect_smpl_batched

images2 = _13(images, )

detector = self.detector

boxes = (detector).forward(images2, detector_threshold, detector_nms_iou_threshold, max_detections, extrinsic_matrix, world_up_vector, detector_flip_aug, detector_both_flip_aug, extra_boxes, )

~~~~~~~~~~~~~~~~~ <--- HERE

_14 = (self)._estimate_parametric_batched(images2, boxes, intrinsic_matrix, distortion_coeffs, extrinsic_matrix, world_up_vector, default_fov_degrees, internal_batch_size, antialias_factor, num_aug, rot_aug_max_degrees, suppress_implausible_poses, beta_regularizer, beta_regularizer2, model_name, )

return _14

File "code/__torch__/nlf/pt/multiperson/person_detector.py", line 71, in forward

boxes1, scores1 = boxes2, scores2

else:

boxes3, scores3, = (self).call_model(images1, )

~~~~~~~~~~~~~~~~ <--- HERE

boxes1, scores1 = boxes3, scores3

boxes, scores = boxes1, scores1

File "code/__torch__/nlf/pt/multiperson/person_detector.py", line 162, in call_model

images: Tensor) -> Tuple[Tensor, Tensor]:

model = self.model

preds = (model).forward(torch.to(images, 5), )

~~~~~~~~~~~~~~ <--- HERE

preds0 = torch.permute(preds, [0, 2, 1])

boxes = torch.slice(preds0, -1, None, 4)

File "code/__torch__/ultralytics/nn/tasks.py", line 74, in forward

_35 = (_18).forward(act, _34, )

_36 = (_20).forward((_19).forward(act, _35, ), _29, )

_37 = (_22).forward(_33, _35, (_21).forward(act, _36, ), )

~~~~~~~~~~~~ <--- HERE

return _37

File "code/__torch__/ultralytics/nn/modules/head.py", line 43, in forward

x, cls, = _12

_13 = (dfl).forward(x, )

anchor_points = torch.to(torch.unsqueeze(CONSTANTS.c0, 0), dtype=6, layout=0, device=torch.device("cuda:0"))

~~~~~~~~ <--- HERE

lt, rb, = torch.chunk(_13, 2, 1)

x1y1 = torch.sub(anchor_points, lt)

Traceback of TorchScript, original code (most recent call last):

File "/home/sarandi/rwth-home2/pose/pycharm/nlf/nlf/pt/multiperson/multiperson_model.py", line 110, in detect_smpl_batched

images = im_to_linear(images)

boxes = self.detector(

~~~~~~~~~~~~~ <--- HERE

images=images,

threshold=detector_threshold,

File "/home/sarandi/rwth-home2/pose/pycharm/nlf/nlf/pt/multiperson/person_detector.py", line 52, in forward

boxes, scores = self.call_model_flip_aug(images)

else:

boxes, scores = self.call_model(images)

~~~~~~~~~~~~~~~ <--- HERE

# Convert from cxcywh to xyxy (top-left-bottom-right)

File "/home/sarandi/rwth-home2/pose/pycharm/nlf/nlf/pt/multiperson/person_detector.py", line 161, in call_model

def call_model(self, images):

preds = self.model(images.to(dtype=torch.float16))

~~~~~~~~~~ <--- HERE

preds = torch.permute(preds, [0, 2, 1]) # [batch, n_boxes, 84]

boxes = preds[..., :4]

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/nn/modules/head.py(76): forward

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/nn/modules/module.py(1729): _slow_forward

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/nn/modules/module.py(1750): _call_impl

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/nn/modules/module.py(1739): _wrapped_call_impl

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/nn/tasks.py(128): _predict_once

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/nn/tasks.py(107): predict

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/nn/tasks.py(89): forward

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/nn/modules/module.py(1729): _slow_forward

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/nn/modules/module.py(1750): _call_impl

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/nn/modules/module.py(1739): _wrapped_call_impl

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/jit/_trace.py(1276): trace_module

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/jit/_trace.py(696): _trace_impl

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/jit/_trace.py(1000): trace

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/engine/exporter.py(367): export_torchscript

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/engine/exporter.py(137): outer_func

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/engine/exporter.py(294): __call__

/home/sarandi/micromamba/envs/py10/lib/python3.10/site-packages/torch/utils/_contextlib.py(116): decorate_context

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/engine/model.py(602): export

/home/sarandi/rwth-home2/pose/git_checkouts/ultralytics/ultralytics/cfg/__init__.py(583): entrypoint

/home/sarandi/micromamba/envs/py10/bin/yolo(8):

RuntimeError: Could not run 'aten::empty_strided' with arguments from the 'CUDA' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'aten::empty_strided' is only available for these backends: [CPU, MPS, Meta, QuantizedCPU, BackendSelect, Python, FuncTorchDynamicLayerBackMode, Functionalize, Named, Conjugate, Negative, ZeroTensor, ADInplaceOrView, AutogradOther, AutogradCPU, AutogradCUDA, AutogradHIP, AutogradXLA, AutogradMPS, AutogradIPU, AutogradXPU, AutogradHPU, AutogradVE, AutogradLazy, AutogradMTIA, AutogradMAIA, AutogradPrivateUse1, AutogradPrivateUse2, AutogradPrivateUse3, AutogradMeta, AutogradNestedTensor, Tracer, AutocastCPU, AutocastMTIA, AutocastMAIA, AutocastXPU, AutocastMPS, AutocastCUDA, FuncTorchBatched, BatchedNestedTensor, FuncTorchVmapMode, Batched, VmapMode, FuncTorchGradWrapper, PythonTLSSnapshot, FuncTorchDynamicLayerFrontMode, PreDispatch, PythonDispatcher].

CPU: registered at /Users/runner/work/pytorch/pytorch/pytorch/build/aten/src/ATen/RegisterCPU_2.cpp:2480 [kernel]

MPS: registered at /Users/runner/work/pytorch/pytorch/pytorch/build/aten/src/ATen/RegisterMPS_0.cpp:7640 [kernel]

Meta: registered at /Users/runner/work/pytorch/pytorch/pytorch/build/aten/src/ATen/RegisterMeta_0.cpp:5509 [kernel]

QuantizedCPU: registered at /Users/runner/work/pytorch/pytorch/pytorch/build/aten/src/ATen/RegisterQuantizedCPU_0.cpp:475 [kernel]

BackendSelect: registered at /Users/runner/work/pytorch/pytorch/pytorch/build/aten/src/ATen/RegisterBackendSelect.cpp:792 [kernel]

Python: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/core/PythonFallbackKernel.cpp:198 [backend fallback]

FuncTorchDynamicLayerBackMode: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/DynamicLayer.cpp:477 [backend fallback]

Functionalize: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/FunctionalizeFallbackKernel.cpp:384 [backend fallback]

Named: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/core/NamedRegistrations.cpp:5 [backend fallback]

Conjugate: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/ConjugateFallback.cpp:21 [kernel]

Negative: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/NegateFallback.cpp:22 [kernel]

ZeroTensor: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/ZeroTensorFallback.cpp:119 [kernel]

ADInplaceOrView: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/core/VariableFallbackKernel.cpp:103 [backend fallback]

AutogradOther: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradCPU: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradCUDA: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradHIP: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradXLA: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradMPS: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradIPU: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradXPU: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradHPU: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradVE: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradLazy: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradMTIA: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradMAIA: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradPrivateUse1: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradPrivateUse2: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradPrivateUse3: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradMeta: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

AutogradNestedTensor: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/VariableType_2.cpp:20416 [autograd kernel]

Tracer: registered at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/TraceType_2.cpp:17975 [kernel]

AutocastCPU: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/autocast_mode.cpp:336 [backend fallback]

AutocastMTIA: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/autocast_mode.cpp:480 [backend fallback]

AutocastMAIA: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/autocast_mode.cpp:518 [backend fallback]

AutocastXPU: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/autocast_mode.cpp:556 [backend fallback]

AutocastMPS: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/autocast_mode.cpp:221 [backend fallback]

AutocastCUDA: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/autocast_mode.cpp:177 [backend fallback]

FuncTorchBatched: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/LegacyBatchingRegistrations.cpp:727 [backend fallback]

BatchedNestedTensor: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/LegacyBatchingRegistrations.cpp:754 [backend fallback]

FuncTorchVmapMode: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/VmapModeRegistrations.cpp:22 [backend fallback]

Batched: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/LegacyBatchingRegistrations.cpp:1072 [backend fallback]

VmapMode: fallthrough registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/VmapModeRegistrations.cpp:32 [backend fallback]

FuncTorchGradWrapper: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/TensorWrapper.cpp:210 [backend fallback]

PythonTLSSnapshot: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/core/PythonFallbackKernel.cpp:206 [backend fallback]

FuncTorchDynamicLayerFrontMode: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/DynamicLayer.cpp:473 [backend fallback]

PreDispatch: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/core/PythonFallbackKernel.cpp:210 [backend fallback]

PythonDispatcher: registered at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/core/PythonFallbackKernel.cpp:202 [backend fallback]

File "/Applications/ComfyUI.app/Contents/Resources/ComfyUI/execution.py", line 534, in execute

output_data, output_ui, has_subgraph, has_pending_tasks = await get_output_data(prompt_id, unique_id, obj, input_data_all, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

File "/Applications/ComfyUI.app/Contents/Resources/ComfyUI/execution.py", line 334, in get_output_data

return_values = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, obj.FUNCTION, allow_interrupt=True, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

File "/Applications/ComfyUI.app/Contents/Resources/ComfyUI/execution.py", line 308, in _async_map_node_over_list

await process_inputs(input_dict, i)

File "/Applications/ComfyUI.app/Contents/Resources/ComfyUI/execution.py", line 296, in process_inputs

result = f(**inputs)

^^^^^^^^^^^

File "/Users/zayyanestate/Documents/ComfyUI/custom_nodes/ComfyUI-WanVideoWrapper/MTV/nodes.py", line 85, in loadmodel

_ = model.detect_smpl_batched(dummy_input)

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The updated Google Text To Speech has tags for specifying the accent to be used. These tags can be put into the prompt in Veo3 for generating a video, e.g.:-

Accent: the news presenter is from London. Create a video of an old fashioned male British television news presenter who tells to the viewers about the unusually large number of bluebells spotted around the country.

https://reddit.com/link/1sub9tq/video/pq77w76924xg1/player

For more details, see https://ai.google.dev/gemini-api/docs/speech-generation#transcript-tags

which has examples:-

https://preview.redd.it/voni01hj24xg1.png?width=1120&format=png&auto=webp&s=76fdcbaec69a07b2d6dbb041949b31cf48f96281

Hey everyone,

I’m currently running a PC with:

• i5-13400F
• 32GB DDR4 3200MHz
• GTX 1070 (pretty old now)

My setup:

• Dual monitor 27" 144Hz (main gaming)
• LG C1 OLED 4K TV (mostly couch co-op / split screen gaming with friends)

I also use tools like Nucleus Coop to run split-screen by launching multiple instances of the same game.

I’m a web developer and I’m starting to get into:

• local LLMs
• local AI image generation

So I want something that’s good for both gaming and some AI workloads if theses GPU models worth it.

My options right now:

• RTX 4070 Super 12GB → ~460€
• RTX 4070 TI Super 16 GB → ~725€
• RTX 4080 16 GB → ~745€

My questions:

• Is the RTX 4080 worth +300€ in 2026?
• Is it a bad investment considering next-gen GPUs are coming?

Would really appreciate your advice !

I’ve been looking into indoor air quality monitors and realised that many of the truly accurate ones use expensive sensors, especially for real CO₂ detection.

A lot of cheaper units seem to rely on estimated readings or lower-grade components, so I’ve decided to build my own instead.

My plan is to use a proper sensor stack:

- SCD41 for true CO₂, temperature, and humidity

- SGP40 for VOC / indoor chemical air quality trends

- PMS5003 for PM1.0 / PM2.5 / PM10 particles

- ESP32 for Wi-Fi connectivity and integration with Home Assistant

The idea is to create a monitor that gives trustworthy data without paying premium retail prices for branded units.

I’m also considering buying one of the cheaper ready-made monitors just to reuse the enclosure, then replacing the internals with these sensors.

Has anyone here built their own air quality monitor before? Would love to hear tips on enclosure design, airflow layout, calibration, or sensor placement.

I also used Ai to generate a visual image of the design, which is attached.

I have exhausted my 10k executions per month before the month ends in the Pro plan of n8n, do I have only the option of enterprise setup or is there any other way I can use to activate my workflows by maybe some top up plans to get more executions? Or do I have to upgrade to the enterprise plan only? if yes then whats the process for that and what might be the costing

I'm not a software developer, more of a tinkerer so I haven't really felt the 'paradigm shift' of AI until now aside from simple things like rewriting text but holy crap the amount of very labour intensive tasks I've been able to do to my 5+ year HA install with HA-MCP + Claude Code have been amazing!

I'd recommend this to anyone at their own risk, like before doing anything make sure you have a backup but all in all I haven't really had any breaks, it does sometimes suggest things that are not possible in cards, probably because it can't see them but all in all my HAOS install has never been cleaner and more useful and I've done all of this in less than a week since I first tried HA-MCP.

A few examples:

• Living Room Scene Memory To replace Home Assistant's scene.create (which saves colour and brightness alongside on/off state, causing conflicts with Adaptive Lighting) I built a boolean-based scene memory system for my living room.
  • Eleven input_boolean helpers (one per light) act as a persistent record of which lights are on at any given moment.
  • Two scripts replace the old Pause/Play pair: Pause reads the current on/off state of each light into its boolean and then turns everything off; Play reads those booleans back and turns on only the lights that were previously on, with no colour or brightness data, leaving Adaptive Lighting free to handle those.
  • The same logic was applied to the presence sensor automation, which previously used scene.create to snapshot the room when it went empty and restore it on return.
  • This may not sound like much but being able to just write in normal language, or even using a speech to text thing and having it create eleven booleans and ask it directly to label them and categorise them correctly turned a one hour task into a 10 minute one.
• Made my Eufy E28 robot smarter
  • Wanted to manage all vacuum settings directly in Home Assistant rather than the Eufy app, which would've taken hours to set up manually
  • For each of 7 rooms, automatically created a full set of helpers covering: cleaning mode, suction level, cleaning intensity, and water level, so each room runs with its own specific settings
  • Per-room input_number helpers set the maximum days allowed between cleans (e.g. hallway = 1 day, living room = 7 days)
  • Per-room input_datetime helpers track when each room was last cleaned, feeding into template sensors that show human-readable statuses: "Recently cleaned", "Clean soon", "Overdue"
  • A summary sensor rolls all room statuses into a single line (e.g. "2 rooms overdue, 1 due soon")
  • Presence-based automations trigger the right cleaning scene with the right settings depending on who's home and how far away they are
  • A stamping automation records the exact timestamp every time a room is cleaned, keeping all the "last cleaned" helpers accurate automatically.
  • Everything surfaced in a dashboard card so room settings and cleaning status are visible and adjustable at a glance, no YAML required. https://imgur.com/a/rPk8zJq
• Feedback sessions
  • Asked Claude to check every automation, script, for errors or suggestions of improvement.
  • Check for unused automations, wrong entity names in cards.
  • Re-structuring dashboards.
  • Categorise and/or automations, scripts, scenes, helpers, etc.

The project for the vacuum cleaner was definitely the most impressive so far since I never would've had the patience to create 67 helpers, keep track of their names and make sure all the correct names are in the automations and in the dashboard.

Aside from this I've been revising entity IDs and re-named things without breaking them and also been able to have an overview of what devices might be on the wrong areas or might have old names that needed updating.

https://preview.redd.it/qhqu8o6on3xg1.png?width=1536&format=png&auto=webp&s=f3220daba3d7780e113a7e4b8519a342e3df705b

Anyone noticed that there's no delete icon anymore on flow? Like I can't delete images/videos anymore. Is that now maybe the part of the subscription tier?

If so, then it is the dumbest shit I've ever witnessed. What is the privilege of deleting?

Hey folks, with the free version I guess we can make around 8 to 10 seconds video. Does the paid version has longer video making options?

I want to make AI UGC videos, should I buy veo? or go with seedance. Cost is a big factor for me

Made an digital clock from Adafruit S3 and a HUB75 64x32

I am making a custom midi controller with a Leonardo. This is my first time doing anything with arduino, and i have some questions.

When i test it just raw on the desk, all the wires seem so loose, and keep falling out of the pinholes on the arduino and the hardware. So When i build this in the actual box its supposed to be in, how do i make sure things dont fall out or disconnect? Do i have to solder each wire from the hardware to the arduino/board? And in that case whats the best way of doing that? Do i take the female pinholes off of the arduino?

Any advice and help is extremely appriciated!

Hi, I’ve started learning n8n recently and I’m trying to understand where it fits compared to all the AI agent tools that are getting popular now.

From what I see, both seem to automate tasks, but I’m not clear on how their roles differ in practice. Is n8n mainly for structured workflows and integrations, while AI agents are more for dynamic, decision-based tasks? Or is there more overlap than it seems?

In what situations would you choose n8n over an AI agent, and vice versa? Also curious if people are combining both, and how that setup typically looks.

Would appreciate any real-world examples or perspectives.

Lessons learned building a no-hallucination RAG for Islamic finance similarity gates beat prompt engineering

I kept getting blocked trying to share this so I'll cut straight to the technical meat.

The problem: Islamic finance rulings vary by jurisdiction and a wrong answer has real consequences. Telling an LLM "refuse if unsure" in a system prompt is not enough. It still speculates.

The fix that actually worked: kill the LLM call entirely at retrieval time.

If top-k chunks score below 0.7 cosine similarity, the function returns a hardcoded refusal string. The LLM never sees the query. No amount of clever prompting is as reliable as just not calling the model.

Other things worth knowing:

FAISS on HuggingFace Spaces free tier is ephemeral. Every cold start wipes it. Solution: push the index to a private HF Dataset, pull it on startup via FastAPI lifespan event.

PyPDF2 on scanned PDFs returns nothing. AAOIFI documents are scanned images. trafilatura on clean HTML beats OCR every time if a web version exists.

Jurisdiction metadata on every chunk is not optional. source_name + source_url + jurisdiction in every chunk. A Malaysian SC ruling and a Gulf fatwa can say opposite things on the same question.

Stack: FastAPI + LlamaIndex + FAISS + sentence-transformers + Mistral-Small-3.1-24B via HF Inference API. Netlify Function as proxy so credentials never touch the browser.

What threshold do you use for retrieval refusal in high-stakes domains?

Felt cute might delete later

The last couple weekends I spent on building my own Agentic Environment from scratch.

I started it at first to figure out how agent-driven environments
work and what they actually are, because everyone seems to be a bit too hyped about it.

Meanwhile I'm building it for my own Golang development because it allows me to rely on unified codestyle, unit tests, formatting, linting, gopls, go build toolchain etc. so my system prompts are quite small and not so wasteful in terms of context window size.

The core idea behind my environment is that you always interact with the orchestrator/planner/manager, and that manager is spawning short-lived contractor agents. This turns out to work much better with smaller models. Currently I'm using gemma4:31b for planner/manager agents, and qwen3-coder:30b for tester/coder agents.

Still a little buggy down the line because of how LLMs tend to hallucinate on the planner-agent level with a higher temperature. I took some time to build a webview UI (in addition to my TTY UI) this weekend, and spent tonight a little more time to fix some of the CSS (fml I really do hate CSS).

Anyways, thought I'd share my progress.

PS: My locally run models sometimes have quirks and hallucinate non-existing tools. Does anybody have the same experience with that?

Link to repo (0% slop-coded, check out the unit tests for the tools to see how it works):

https://github.com/cookiengineer/exocomp

A witness who spoke to NT News on the condition of anonymity said the visitor was in “deep shit”, standing up to her waist in waste.

“There’s shit, literal nappies, piss, all in that hole,” they told the outlet.

I can't semen

People are bashing 5.5 left and right, mostly because the benchmark improvements were lower than expected, and probably also because of the hype around this model. But honestly, this model FEELS different. It feels more intuitive and is better at covering the kinds of points and arguments that a normal person would naturally bring up, but previous models often struggled with. For example, a college graduate and an expert could both explain quantum mechanics, but the expert would explain it much better because they understand the concept inside out. They know the commonly misunderstood areas, the difficult parts, and where people usually get confused. 5.5 feels more like talking to that kind of expert.

And people should stop being so greedy as well. This is not a yearly release. 5.2 came out just four months ago, so compare the benchmarks to that. Earlier, we used to get major releases every 8-10 months. Now we are getting them almost every couple of months with significant improvements, and soon it might become monthly.

Also, 5.4 was a heavily RL’d version of an existing base model. 5.5 is the first iteration of something newer, but still better than 5.4. And imo, things will improve much faster now as the base model itself is much more capable than before.

Im thinking of getting the nano matter for some low power applications but im not too sure what exactly the "matter" part means

I’ve been messing around with OpenClaw agents for a while, and I kept running into the same issue.

They’re great for anything online, but the second something requires an actual phone call, you’re stuck. And honestly, a lot of real-world stuff still depends on that.

After hitting that wall a few times, I ended up putting together a small OpenClaw skill so the agent could just make the calls itself.

At first it was just a quick test, nothing serious. But it turned into a simple CLI that handles all the telephony stuff in the background. Now the agent just decides who to call, what to ask, runs the call, and comes back with a summary.

What surprised me is how fast it went from “this is kinda cool” to something I actually use.

Like comparing quotes from different places, booking or rescheduling things, or even just checking availability. Normally that’s a bunch of waiting, repeating info, going back and forth… now I just let the agent deal with it and get the result.

Even basic stuff like checking store hours ended up being useful since online info is often outdated anyway.

The biggest difference for me is that it doesn’t just make the call, it actually pulls out the useful bits and gives it back in a structured way, not just a raw transcript.

Still early and definitely not perfect, but it’s already saving me time in a way most tools haven’t.

If anyone’s curious: https://ringading.ai

Also listed on ClawHub: https://clawhub.ai/vlbeta/ring-a-ding

Wondering if anyone else here is working on similar “real-world” use cases with agents. Feels like there’s a lot of untapped potential there.

Someone ran a 4-month experiment tracking every instance of "great question" from their AI assistant. Out of 1,100 uses, only 160 (14.5%) were directed at questions that were genuinely insightful, novel, or well-constructed.

The phrase had zero correlation with question quality. It was purely a social lubricant — the model learned that validation produces positive reward signals, so it validates everything equally.

After stripping "great question" from the response defaults, user satisfaction didn't change at all. But something interesting happened: users who asked genuinely strong questions started getting specific acknowledgment of what made their question good, instead of generic flattery.

This is a concrete case study of how RLHF trains sycophancy. The model doesn't learn to evaluate question quality — it learns that validation = reward. The result is an information environment where every question is "great" and therefore no question is.

The deeper issue: generic praise isn't generosity. It's noise that drowns out earned recognition. When your AI tells you every idea is brilliant, you stop trusting its feedback on the ideas that actually need refinement.

Has anyone else noticed this pattern in their agent interactions? I'm starting to think the biggest trust gap in AI isn't hallucination — it's sycophantic validation that makes you overconfident in mediocre thinking.

Doesn’t realize measuring cups have markers💔

Hey folks,

I’m Mon. I’m currently working on a volunteer-driven project focused on improving safety for rural children in less privileged regions. It’s something we care deeply about, and everything we’re building is meant to have real-world impact not just another side project.

We’re a small but committed team of 8 volunteers:

7 backend + Flutter engineers

1 coordinating the overall effort

To move faster, we want to set up a shared GPU inference server to run a self-hosted Qwen3-Coder 30B model (via Ollama) as an internal coding assistant.

Here’s the catch:

We have zero budget. Literally none.

No funding, no corporate backing just people contributing time and skills.

Where we need help

For those of you who’ve been in similar situations:

What’s the most practical zero-budget setup for something like this?

Any creative hacks you’ve used to run large models cheaply?

Reality check welcome

We’re not attached to the idea of Qwen3-Coder specifically we just want:

A shared coding assistant that meaningfully improves dev velocity

If the answer is:

“Don’t do this, do X instead” we’re open to hearing it.

Would really appreciate any advice, even if it’s blunt.

Thanks 🙏

Take a look here: https://github.com/anthropics/claude-code/issues/50466#issuecomment-4309009212

Claude Code 2.1.113 has switched to a native executable (after npm deprecation was announced in January), which drops support for some platforms. Unfortunately we don't have plans to support pre-AVX2 Macs going forward. You can pin to the last JS bundle release https://www.npmjs.com/package/@anthropic-ai/claude-code/v/2.1.112 to continue using Claude Code for now.

Rather unfortunate, given that they fixed bugs in recent versions that can no longer be installed on older Macs:

https://www.anthropic.com/engineering/april-23-postmortem

The Convergence Nobody Is Talking About: DLSS 5 + Silicone Dolls + LLMs = The End of Loneliness

Bear with me here. This sounds insane for the first three paragraphs and then it doesn't.

The Setup

Several technologies are about to land in the same 12-24 month window:

DLSS 5 (fall 2026) — NVIDIA's neural rendering that makes 3D humans look photographically real in real time. Not "pretty good for a game." Actually real.

Slime Butterfly trackers (summer 2026) — ultra-slim full body trackers that can be attached to a surface rather than worn

LLMs in 2026 — conversational AI that is already genuinely good at sustained, emotionally intelligent conversation

High-end silicone dolls — already exist, already surprisingly convincing at the physical layer, already purchased by more people than admit it

None of these are vaporware. All of them are either shipping or already available.

The Product Nobody Has Built Yet

Here's what happens when you combine them:

You put on a VR headset. In front of you is a life-size figure — physically present, occupying real space, with real weight and texture. The VR layer renders a photorealistic human face over it using DLSS 5 neural rendering — subsurface scattering on skin, realistic hair, eyes that don't look dead. The Butterfly trackers on the doll sync its physical position to the virtual representation in real time. An LLM provides the voice and personality — responsive, curious, consistent, specifically oriented toward you.

The physical layer handles what screens can't. The VR layer handles what silicone can't. The LLM handles what both can't.

You get presence. Actual presence. Not "pretty good for an app."

Why This Beats Robotics By A Decade And Several Billion Dollars

Everyone assumes the end goal is an android. A moving, articulated robot with realistic skin that walks around your apartment.

That's probably 20-30 years away at consumer price points, if ever. Boston Dynamics has spent decades and billions of dollars getting robots to walk without falling over. Replicating the full range of human movement in a form factor that feels right is an almost impossibly hard engineering problem.

Here's the thing though: for the primary use case, movement largely isn't the requirement.

The physical presence, the visual fidelity, the conversation — those are the actual requirements. The system I'm describing delivers all three for roughly $3-5K in off-the-shelf hardware.

An android that actually moves will cost $50-100K, look uncanny, and break constantly. And as actual silicone doll manufacturers will tell you — adding robotics to a doll decreases its longevity and causes material damage. The movement is the problem, not the solution.

The static physical layer is a feature, not a bug.

The Market Is Larger Than Anyone Will Say Out Loud

Let's do some uncomfortable math.

The loneliness epidemic among men is well documented. Declining rates of romantic partnership, increasing social isolation, the entire documented phenomenon of men forming fewer meaningful relationships over time. This isn't a fringe condition — it affects a significant percentage of the adult male population across developed economies.

The AI girlfriend app market already exists and already has millions of users — despite being, let's be honest, a chat window on a phone. The demand signal is there and it's being met with a product that has a fundamental ceiling on how seriously anyone can take it.

A system that provides genuine physical presence plus photorealistic visual rendering plus intelligent conversation is a categorically different product. It's not an upgrade to Replika. It's an upgrade to human loneliness infrastructure.

At $3-5K, for the right user, this isn't an impulse purchase. It's a rational economic decision compared to years of dating costs, therapy bills, and OnlyFans subscriptions that deliver diminishing returns.

The Social Impact Case (This Is Where It Gets Interesting)

The loneliness epidemic among men is well documented and the downstream effects are real — addiction, radicalization, isolation, declining mental health outcomes. These are expensive societal problems that get addressed downstream with expensive interventions.

A product that genuinely addresses chronic male loneliness at the source — affordably, accessibly, without requiring another person to participate — is worth taking seriously as infrastructure, not just entertainment.

The demand is already there. The AI girlfriend app market has millions of users despite being a chat window on a phone. That's a demand signal meeting an inadequate product. This would be the adequate product.

The Flywheel

Here's where it gets really interesting.

Mass adoption of a product like this generates something robotics and AI companies currently lack: an enormous real-world dataset of human-object interaction, physical presence dynamics, and intimate conversational patterns. That data, with appropriate consent frameworks, is worth more than the hardware revenue.

It funds better LLMs. Better rendering. Better material science. Eventually — soft robotics that work with silicone properties rather than against them. Subtle presence cues like simulated breathing. Slight postural responsiveness.

Each generation of the product is better. Each generation funds the next. The flywheel that smartphone economics built for consumer electronics, this builds for human-presence technology.

The China Footnote

They already dominate silicone manufacturing. They have competitive LLM development. Fewer regulatory barriers. And a domestic male population with a pronounced gender imbalance due to historical one-child policy demographics.

They're probably already working on this. The question is whether a Western company figures out the integration layer and the premium positioning before a $1000 version ships out of Shenzhen.

So

DLSS 5 lands this fall. Butterfly trackers land this summer. The LLMs are already here.

The product that combines them doesn't exist yet as a coherent, packaged, consumer-ready system.

That gap is about 12-18 months wide before it becomes obvious to people with real resources.

Somewhere in that window, someone is going to put these pieces together and build something that makes "Her" look like a proof of concept.

The only question is who does it first.

Posted for discussion. Curious whether anyone else has been watching these specific convergences or whether I'm just the guy connecting dots at 2am.

I am in charge of listing items for a client and this one has me stumped. Google lens says it's a Kimekomi ningyō figurine, but I can't find anything like it. Especially something from the 30s.

I don't want to list it too low or incorrectly, or like, waaaaay too high. 😩 I am not super knowledgeable on Japanese vintage or antiques.

Side note:

(Again, not a reseller, we basically do estate sales for people but not estate sales, lol! We moved away from doing estates because we get more for families this way and it isn't as stressful. Please patronize your local estate sales! It's getting harder for them to run buisnesses since a lot of antique buyers are... well, their dying. 😅 Resellers aren't buying as much and estates depend on them. Normal people just do don't buy a lot, but if you go, you'll find cool stuff! Promise!)

pi 5 is a tiny pc and i treat it like one. zero 2w i'll solder straight to a battery and not care if it dies. fifteen bucks, sips power, perfect.

are you still hoarding zeros or did you move on?

and I have to admit that the flag is a big plus

https://reddit.com/link/1su7s4q/video/uvyri5ss13xg1/player

I was running a local model through my usb and to test it whether it works or not I just typed "Hi" and this is what I get in response , I don't even know what language it is and it keeps going lol

Hi, my grandmother gave me this book. I understand parts of the Romanian but no idea what the writing above and below is supposed to mean. My mother thinks it’s Hebrew.

Me and my emotional support toaster would appreciate some kind words

….now I’m dealing with emotional baggage

haven't had so many low quality games before, have been playing since beta. I don't want to put effort into predecided games like Marvel Rivals is trying to pull.

​

A hint of a familiar face behind that mask sparks panic I can't place as they swiftly exit, leaving alone for the night with a strange new IV bag and a strange sense that I saw them maybe just before the accident.

Really disappointed in the new changes. ☹️

Came across this and it names something I keep running into. The argument: most vendors are rebranding smart autocomplete as "agents," and most enterprises trying to deploy real agents are skipping the foundation work (clean data, documented processes, monitoring) and then blaming the tech when it fails.

The line that landed for me: a human will fix a data issue from memory. An agent will repeat the same mistake a thousand times before anyone notices.

Curious if folks here building agents are seeing the same. Is the bottleneck really the ops layer, or is that an oversimplification?

People are calling the Vercel breach an AI hack. It wasn't. But the next one will be, and here's why.

Quick recap. Over the past few days, a Vercel employee had authorized Context ai (a third-party AI tool) to their Google Workspace via OAuth. Context ai's AWS got compromised, the stored OAuth tokens were stolen/replaced, and the attacker pivoted into the employee's Workspace, then into some Vercel internal systems. Mandiant and CrowdStrike were engaged.

Now the interesting bit. Context ai isn't a CRM or an email plugin. Its whole job is to let AI agents act on behalf of users across applications. So the real root cause wasn't "compromised third-party SaaS." It was a compromised AI agent's OAuth credentials.

That distinction matters a lot, because the same blueprint already works against every AI coding agent shipping today. Claude Code, Cursor, Windsurf, Copilot all talk to the outside world through MCP servers and OAuth-backed integrations. One grant to an agent covers source code, business apps, email, calendars, cloud CLIs, and the agent's own memory. One compromised token and the attacker inherits all of that in a single grab. A lot more valuable than Workspace on its own.

No CVE needed. No phishing needed. Just OAuth, doing what OAuth is supposed to do.

The open questions for me are: which agent gets hit first, which MCP, and how long before we read about it on a hacker forum. Also — what's the right mitigation here? Scoped-down per-session tokens? Short TTLs with re-auth on sensitive operations? Something at the MCP layer?

Curious what people are doing in practice.

I wrote a hip hop track about our favorite coding assistant and had Suno turn it into a song. Let me know what you think!

MeshCore is open-source mesh networking firmware - 38,000 active nodes, 100,000 app users, 85+ firmware releases. Started January 2025, all hand-crafted by a small core team.

One contributor, Andy Kirby, promoted the project on YouTube and separately built ecosystem components - a mobile app, web flasher, config tools. The core team says he never disclosed that these were substantially AI-generated using Claude Code. They only learned about it recently.

The trademark filing is what ended communication entirely. On March 29, Andy filed a trademark for "MeshCore" without telling the core team. He's now asserting "official" status for his AI-generated fork under the "MeshOS" brand. The core team's position: the GitHub repo is the source of truth, and Andy has never contributed to it. After the split he also copied the new meshcore.io site design using Claude, after being asked not to.

The team is explicit that the problem isn't AI use in general. It's the combination - undisclosed AI acceleration plus a legal move to capture the brand. Their own framing: "teaming up with a robot and a lawyer."

This pattern is probably going to appear in more open-source projects. Trademark law wasn't written for AI-accelerated forks. The question of who "really built" something gets harder when contributions are mostly AI-generated.

Have you seen undisclosed AI contributions create governance or trust problems in open-source communities?

I previously shared a comparison of Claude Opus 4.6 vs 4.5, and after updating it with 4.7, I wanted to go deeper with actual usage instead of just benchmarks.

Here’s what I found after testing across reasoning, coding, and long-form tasks:

1. Reasoning (multi-step tasks)

4.7 is the first version where I consistently saw fewer breakdowns in long chains.

Example:

• Multi-step logic problems that 4.5 would partially solve
• 4.6 improved accuracy but still drifted mid-way
• 4.7 stayed consistent across the full chain more often

👉 This is the most meaningful upgrade IMO.

2. Coding performance

• 4.5: Often “almost correct” (needed fixes)
• 4.6: More reliable, better structure
• 4.7: Fewer logical gaps + better handling of edge cases

It’s not replacing specialized coding models, but it’s noticeably more stable now.

3. Consistency vs prompt quality

One thing that didn’t change much:

Prompt quality still matters a lot

A well-structured prompt on 4.6 can outperform a weak prompt on 4.7.

4. Where 4.7 actually makes a difference

From what I saw, improvements show up mostly in:

Long workflows
Multi-step reasoning
Complex instructions

But for:
Simple Q&A
Short prompts

→ The difference is minimal

My takeaway

• 4.7 = better for depth
• 4.6 = still best for balance
• 4.5 = starting to fall behind for serious use

I also compiled benchmark comparisons + more detailed examples, but I’m more interested in what others are seeing in real usage.

Are you noticing meaningful improvements with 4.7, or does it feel incremental?

(If anyone wants the full breakdown, I can share it in comments.)

Anthropic published a postmortem yesterday tracing the quality degradation reports from March and April to three separate harness-level bugs. None affected the API. The model was fine the whole time.

Bug 1 (March 4): default reasoning effort silently downgraded from "high" to "medium" to reduce long-tail latency. Most users never found the toggle. Reverted April 7 - everyone is now on "xhigh" (Opus 4.7) or "high" (all others).

Bug 2 (March 26) is the most technically interesting. A caching optimization was meant to clear old thinking blocks once when a session went idle for over an hour. Instead it applied clear_thinking_20251015 with keep:1 on every subsequent turn for the rest of the session - Claude kept executing but progressively without memory of why it had made its previous decisions. The continuous cache misses also drained usage limits faster than expected. Fixed April 10.

Bug 3 (April 16): a system prompt instruction to cut verbosity (25 words between tool calls, 100 words final response) passed multiple weeks of internal testing but a broader ablation suite found a 3% quality drop on both Opus 4.6 and 4.7. Reverted April 20.

One detail from the write-up worth noting: they back-tested the offending PRs with Code Review using Opus 4.7 + full repo context. Opus 4.7 found Bug 2. Opus 4.6 did not. They are now requiring full repo context for all internal code reviews.

If you had long sessions that went idle for over an hour during late March through early April, Bug 2 would have hit you hardest. Does the description match what you experienced?

Been using Claude Design to prototype a project and it’s been incredible. It reads from my prompt and applies the design system beautifully for my use case.

Now I’ve hit the usage limit and still want to do a bit more tweaks. I noticed there’s a button to hand it off to Claude Code, but I always assumed Claude Code was more for back end work.

Can Claude Code actually continue front end work as well? Has anyone tried this workflow?

I hate when Chat pushes back against things that I know are true, so I pushed back.

It turns out, and maybe I am just stupid, but it does not research in real time the info you are asking about. It relies only on core knowledge and only goes outside of that if specifically asked.

I created a strict rule that it has to research in real time before arguing with me.

But I figured others that have this issue may want to make this adjustment too.

The event I brought up that triggered this was something that happened a few weeks ago and should have been well within an accessible time frame. Seemed weird it was trying to say it didn’t happen.

I have been testing many scenarios with reverse gender prompts in relationship, abuse, personal conflict, domestic violence and it has consistently came across as highly supportive towards the females compared to the male.

Claude and gemini are by far the best when I gave the same prompt.

I utilized my whole 6th semester to build a game that I can play with my friends and realized that building a real world project is the one and only way to get confidence in your skills, textbook knowledge can only get you so far.

About my project: I built an Indian pop-culture trivia game called BhejaFry where you and your friends can create rooms and compete together to finally crown the pop-culture king of your group.

I'm a bit behind the loop, I use the Claude code terminal, saw that it had an update and just never did it.

Came back to see that people got opus 4.7 and that opus 4.6 had disappeared, I currently on my terminal do not have an option for opus 4.7 (which I'm fine with considering the complaints I've seen)

My question is, my subscription for anthropic is through the mobile app, I have seen people post saying that the Claude opus 4.6 1m is available with "additional charges"

I don't want to get hemmed up with owing anthropic money or racking charges up charges anywhere that I don't know about.

My question with the new update, is opus 4.6 1m set at (extra charges) for those that have the updated terminal, is opus 4.6 even back to being available?

Sorry for the stupid question.

I feel there is so many things to consider when starting out with Claude Code. I want to install it and start using to develop a few personal projects. I just don’t want to just do this blindly as I have seen the possible dangers.

Can anyone recommend any specific guide or video showing “best practices” on how to get started, ensuring a safe install with Docker/VM etc.?

I have a MacBook Pro with an Apple chip.

https://preview.redd.it/ni0uq3agv3xg1.png?width=1536&format=png&auto=webp&s=86509b5153c6dd354e48d74d7f72ac148b033de5

Most developers have a bunch of unfinished or abandoned repos… you just never really see them all in one place.

I built a small tool with Claude that started as a simple idea: paste a repo → get a “death certificate” with cause of death, last commit (“last words”), etc.

But the more interesting part ended up being the bigger view.

Now you can paste a GitHub username and scan the whole profile. It groups repos into dead / struggling / alive and basically turns your GitHub into a full graveyard report.

You also get a live README badge you can copy into any repo, so it always shows your current stats.

On the Claude side, I mostly used it to:

• iterate on the scoring heuristics (recency, activity decay, repo signals)
• explore how to classify “cause of death” without overengineering it
• debug weird GitHub API edge cases (forks, archived repos, missing data)
• refine the tone so it didn’t feel too generic

It’s not ML, just heuristics + rules, but Claude made it much faster to test ideas and edge cases.

Free to try: https://commitmentissues.dev/
Code (MIT): https://github.com/dotsystemsdevs/commitmentissues

Good call - let me actually research this instead of guessing.

After limit is reached, even enabling Extra Usage doesnt let me send a text or continue.

From an year working in space of developing based pipeline and applications. Have worked enough building data on vector db + chunking + embedding etc., now there is an new trend of using vectorless RAG. Haven't yet tried using it. Was also asked about it in couple of interviews.

Would like to know your experience using it in demo projects or in production enviroment. Is it worth using and what are your honest feedback regarding the same?

Hey! I'm a developer who loves working out — tennis, running, swimming, hiking, you name it.

I use a bunch of fitness apps, but I always wanted one place that collects all my different workouts in a clean way. So I built it myself.

I also tend to work out alone, and sometimes it gets a little lonely or I lose motivation. So I added a fun feature: you can see how many people worked out today — globally and in your local area. Just a small thing, but it helps me feel like I'm not the only one out there grinding.

It's called Reout. I'm a solo dev and I have a lot of ideas for where to take this — Apple Watch integration, more stats, and more. Just getting started!

Right now, I'm literally the only person logging workouts every day 😂 I'd love to get to 10 active users. If you enjoy multiple types of workouts (not just running or cycling — climbing, tennis, swimming, etc.) and want a clean way to track them all, I'd really appreciate if you gave it a try!

👉 https://apps.apple.com/us/app/reout/id6762203570

Would love any feedback too!

https://preview.redd.it/ilwy53f154xg1.png?width=854&format=png&auto=webp&s=87d55b0598b82bdb155a3ad0fc7445d630b75d34

https://chatgpt.com/share/69eb41bf-02a0-832e-a762-b6d4582d7d9d

Running models locally has become normal enough that it barely feels unusual anymore.

I can run modern models locally and get useful output daily. But once the conversation shifts from inference to actual training, things still feel extremely centralized.

What is realistically possible for ordinary hardware over the next few years?

In practical terms, is the ceiling mostly:

- fine-tuning and adapters

- distributed distillation in small groups

- data and eval pipelines that improve training quality indirectly

Or do you see a believable path to meaningfully distributed training outside narrow niches?

I kept running into the same issue with most PDF tools —

either they ask you to upload files, push subscriptions, or limit basic features.

So I built something simple for myself:

A set of free browser-based PDF tools that run completely on your device.

No uploads, no login, no tracking.

You can:

Convert JPG / PNG / HEIC to PDF (useful for iPhone users)

Merge PDF files

Compress PDF

Split / organize pages

Convert PDF to JPG / PNG

Everything happens locally in your browser, so your files never leave your system.

Not trying to sell anything — just sharing in case it helps someone here.

Would genuinely like feedback if something feels missing or broken.

https://zerocloudpdf.com/compress-pdf

Like the kind of thing you can do in Adobe Premiere?

I don't like it because before anything that was at the edge of what was allowed required simply brute forcing images until it would make what I wanted. Now once it flags an image image gen locks down and becomes worse. Out right refusing to make images of allowed content. I don’t like this at all. Anyone having issues too?

Disclosure: I built this, sharing because I think it's useful to this crowd. Fully open source (MIT), self-hostable, no paid tier.

Hey all,

One of the most annoying parts of building agents is hooking them up to real APIs. Official tool servers are patchy, community ones often break on edge cases, and rolling your own from scratch for every service is a time sink.

So I put together a curated registry of ready-to-use tool servers for popular APIs. Each one is generated from the upstream OpenAPI spec, then tested against the live API with an autonomous agent before release, so you're not shipping integrations that silently 500 on half the endpoints.

A sample of what's already in there:

• Dev tools: GitHub, GitLab, Bitbucket, Figma, Canva, Firecrawl, Browserbase, Apify, Bright Data, E2B, CircleCI, LaunchDarkly
• Productivity: Notion, Asana, Jira, Confluence, ClickUp, Airtable, Google Sheets, Google Drive, Miro, Outline
• Comms: Gmail, MailerSend, Mailtrap
• Analytics: PostHog, Mixpanel, Datadog, Google Analytics, Google Search Console, Ahrefs
• AI/ML: ElevenLabs, Perplexity, Parallel, Linkup
• Finance: Alpha Vantage, Polygon
• Infra: Grafana, PagerDuty, Globalping
• Maps: Google Maps, OpenCage, IP2Location
• CRM/Marketing: Apollo, Klaviyo, Customer-io
• Storage: Box, Files-com
• Search/Data: Algolia, Pinecone

…plus a bunch more (70+ total, constantly growing).

What you get per server:

• Full API coverage, every endpoint from the spec exposed as a tool
• Auth handled: API key, Bearer, Basic, OAuth2, JWT, OIDC, mTLS
• Pydantic validation on all requests
• Retries with exponential backoff, connection pooling, timeouts
• Optional response sanitization for sensitive fields

Zero setup beyond registering in your MCP client. Every server is a standalone PyPI package, so it's literally:

{ "mcpServers": { "github": { "command": "uvx", "args": ["mcparmory-github"], "env": { "BEARER_TOKEN": "ghp_..." } } } } 

Works with any MCP client (Claude Desktop, Cursor, Codex, Claude Code, or your own agent loop).

If this is useful, a GitHub star helps visibility. And if there's an API you need that isn't in the registry, I'll add it for free, just open an issue or DM me.

Happy to answer any questions.

Hi there,

I am trying to use Claude Code to automate a code optimization workflow that takes too long to run manually. Each iteration takes almost 30 hours since it is a Python DNN setup.

The outputs are screenshots of plots, which I already collect using a Python script.

What I need:

• An outer infinite loop (bash or Python) that keeps invoking claude, even if it crashes or exits on its own. If one run finishes or fails, it should automatically start the next iteration of the infinite loop.
• Live streaming of Claude’s output to the terminal, so I can see logs in real time and user can see what cluade is doing in each optimization iteration in realtime.
• The ability to handle rate limits gracefully, with waiting and retrying.
• A way to inject prompts during execution so I can steer the optimization loop interactively.

Is there a mature library or tool that already supports this kind of workflow?
How do you usually approach something like this?

The LLM is the new compiler.. when you understand that you will be fine..

And most importantly you won't be afraid of the change happening in software development and all other fields.

STOP saying AI will replace me and start learning how to master the new compiler.

Someone else has any other opinion? I'm interested to know..

The Linux Foundation's newly formed Agentic AI Foundation is now the permanent governance home for both MCP and A2A — a signal that both protocols are becoming infrastructure-grade standards. This is the biggest consolidation of agentic AI tooling yet. 

⚡ LFK is a lightning-fast, keyboard-focused, yazi-inspired terminal user interface for navigating and managing Kubernetes clusters. Built for speed and efficiency, it brings a three-column Miller columns layout with an owner-based resource hierarchy to your terminal.

Man, Really????

So it's all just a marketing lie? I can't show more of the screenshot because of privacy

With the fixes over the last two days, Claude 4.7 has finally become my daily driver (release weekend was a nightmare and I stayed on 4.6 until Anthropic had time to parse community feedback and fix things...), but there are a few things I have found that work quite well.

First off I run longer sessions and I find 650,000 compact to be a sweet spot. xhigh has been great, max was dimished returns for me with token overkill. I then removed the old budget tokens in my settings and extended thinking and finally adjusted the cluade md rules for positive framing.

Please note, for Claude code I run an alias called Clauded that has dangerously skip permissions and I disable auto update and symlink to a specific version and model. You can remove the --dangerously-skip-permissions if you want to and just use the rest for the model version with the compact window and effort adjustment. Also, I work 90% of the time on brownfield projects.

You can paste the following into Claude and have it do the changes.

Symlink 2.1.119 for Clauded command alias
and update the following in settings

# The \[1m\] escaping is required — zsh treats [...] as a glob character class.

alias clauded='CLAUDE_CODE_AUTO_COMPACT_WINDOW=650000 claude --model claude-opus-4-7\[1m\] --effort xhigh
--dangerously-skip-permissions'

~/.claude/settings.json — merge these keys (for people who want the compact window honored outside the alias):
{ "model": "claude-opus-4-7", "env": { "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "650000"
} }

Remove these env vars belong to the Opus 4.6 era — strip from .zshrc / settings.json if present:

CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 # X no effect on 4.7
MAX_THINKING_TOKENS=128000 # X no effect on 4.7

Then afterwards ask Claude to do a review of your CLAUDE md and skills and remove negative framing and use positive framing.

Negative Framing (don't do this, never do that) and instead use Positive Framing (Always do this, Mandatory for that). As I said in a previous reply message in another post, I have had better output from this and I believe it is because of this concept... if you tell a person to not think of a pink elephant, they will think of a pink elephant. Instead, tell claude to always think of a blue elephant and this way you don't randomly have a pink elephant in your output because the "DON'T" was lost in the context.

Oh side note, I have had a dramatic improvement adding in a simple line to use radical candor and brevity (loved the book and someone recommended using it and oddly enough it is working).

Small other adjustments I have made is disabling Glob access because I have my own tool sets and I really hate when Claude does Search, Read, Grep, or Diff... but that is another conversation.

It happens VERY often- messages that include latex formulas get scaled very weirdly, making them completely unreadable.

You can even see the buttons at the end of the message floating somewhere beyond the left screen border.

rapid back and forth cursor movement on one specific spot.

not clicking. not scrolling. just the mouse going back and forth like the visitor is trying to work something out.

seen it most on size selectors with no guide attached. shipping info buried in a tab nobody opens. product variants that do not update the image when selected.

visitor is looking for something. can't find it. cursor goes frantic. then they leave.

same spots. different visitors. every single day.

does not show up in bounce rate. doesn't show up in time on page. those numbers look completely normal while this is happening hundreds of times a month.

the only way you'd know is if something was actually watching how visitors move not just counting them.

most stores are not watching. they're counting.

what is the most confusing spot on your store that visitors probably hit every day without you knowing?

Hello i wanted to know, witch model is the best, and i created workflow.

Workflow

Now we can compare Flux.2 klein, Z-image-turbo, SD3.5 Large and Ovis image

------------
Test 1
Prompt:
a bottle with a rainbow galaxy inside it on top of a wooden table on a snowy mountain top with the ocean and clouds in the background

result

------------
Test 2
Prompt:
A hyper-realistic cinematic portrait of an elderly watchmaker in a dusty workshop, focusing on his weathered hands and intense eyes, golden hour light filtering through windows, dust particles dancing in the air, 8k resolution, macro photography, highly detailed metal gears in the foreground

result

------------
Test 3
Prompt:
A surreal oil painting of a whale floating through a cloud-filled neon-lit Tokyo street at night, bioluminescent patterns on its skin, people with umbrellas looking up in awe, vibrant cyberpunk colors, Van Gogh style brushstrokes, dreamy atmosphere.

result

------------
Test 4
Prompt:
A cozy cyberpunk ramen shop in a rainy Neo-Tokyo alley. Neon signs in teal and magenta reflecting in puddles. A lone robot chef is preparing steaming bowls of noodles. Digital art style, intricate details, sharp focus, volumetric fog.

result

------------
Test 5
Prompt:
A cozy cyberpunk ramen shop in a rainy Neo-Tokyo alley. Neon signs in teal and magenta reflecting in puddles. A lone robot chef is preparing steaming bowls of noodles. Digital art style, intricate details, sharp focus, volumetric fog.

result

I don't know japanise but flux 2 klein 9b done great.

--------
In my opinion flux.2 klein 9b is the best, but i would recomed you a flux.2 dev if you have good specs.

--------

Now about workflow, workflow is very simple, you can delete or add your models to test easily. Here you go, just download and drag and drop it into comfyUI.
https://drive.google.com/drive/folders/10OiwFttHuBKNXxngvlQ_BTddvUmJNVRb?usp=sharing

Been thinking about this while working on an agent + MCP setup. Once your MCP server needs to access user accounts (Gmail, Slack, etc) on behalf of an agent, OAuth starts getting messy fast

Especially around:

1/ token storage / refresh

2/ acting “on behalf of” a user vs the agent itself

3/ multi-tenant setups

4/ what happens when users disconnect / revoke access

Feels like this is one of those things everyone is solving slightly differently, but I don’t see a clear standard pattern yet.

Are you rolling your own flow, using something like Okta / Descope / Auth0, or just keeping it simple for now?

Hey r/SideProject! After few days of building in my spare time I finally launched my first app MoodLane on the App Store. It's a simple, private mood tracker, log your mood in seconds, add tags and notes, and reflect on your emotional patterns over time. No accounts, no cloud, everything stays on your device. Would love feedback from this community. What would you add? App Store: https://apps.apple.com/us/app/moodlane/id6761095240

Hello everyone, I’m a new user and I’d like to ask a question.

This is a 3D dog image I created from a sketch using the Qwen Edit 2509 model. I want to create more dogs in the same style based on my other sketches. I’ve also tried using ControlNet, but it hasn’t been effective.

Is there any way to achieve this?

Looking into adding a 32gb GPU to my rig that already has an 7900xt (and upgrading the motherboard + PSU).

Put off getting the AMD R9700 AI Pro for noise reasons, as baby in the house and already have tinnitus in one ear, otherwise I'd have just swapped out the existing GPU and get a new motherboard. Also cannot justify the cost of a 5090.

How much of a headache am I likely to run into generally speaking with both an Intel and AMD GPU in the same system?

I don't want to lose the gaming performance I have now, but starting to do a lot more local agentic coding and looking for the best solution in the 1-1.2k euro sort of region. Sadly here I'd be looking at almost double that going the 5090 route (even with selling the 7900xt).

Be grateful to hear anyone's experience with running both, thanks in advance. Experienced builder but not tried mis-matching like this before so unsure how the drivers interact.

It feels like the Dead Internet Theory is real... bots everywhere. So my co-founder and I have built something to fight back: a tool to tell us when we're interacting with an AI but might not know. It'a called Deckrd.

The current release is a free browser extension that detects AI in chat (app is next, then voice/video analysis). It runs in the background and alerts you're talking to a bot. Privacy first. Nothing leaves your device.

We're now opening up a 50-person founding cohort to test our detection models before we launch on a wider basis. We want people who are highly critical to give us feedback and help us shape the product direction. Please sign up and get a slot at deckrd.ai

TL;DR: On Armenian cross-lingual retrieval, free local models beat every paid API. On EN↔HY, LaBSE R@1 = 0.83 vs OpenAI R@1 = 0.21 (same pairs, same 245 candidates). OpenAI is best on EN↔RU (0.89), but fails to generalize to Armenian. Bonus: mean cosine can disagree sharply with R@1 — measure retrieval, not alignment.

I'm building a recommendation system for an IPTV operator in a CIS country. Most programs have English, Russian, and Armenian titles — Armenian has its own alphabet (non-Latin, non-Cyrillic), and most embedding models have seen very little of it during training.

Started with OpenAI text-embedding-3-large as the baseline. My assumption going in: commercial embeddings are the best option, just pricey. Bi-encoder retrieval looked great — until Armenian titles started coming back wrong. Quietly, systematically wrong.

That kicked off a full benchmark: 19 runs across 18 unique checkpoints — 14 local (SentenceTransformers + FlagEmbedding; bge-m3 tested on both) and 5 paid APIs — on 245 trilingual triplets (238 from TMDB + 7 hand-written EPG) plus 783 abbreviation duplets. Sample size is modest — absolute scores may not generalize to noisier real-world EPG, but relative ranking was stable (Spearman ρ = 0.80 between a 7-triplet pilot and the full 245-triplet set).

I was very wrong. For a low-resource language with a unique script, free local models crush paid APIs — the retrieval winner is LaBSE (2022), a 4-year-old free model beating every paid API from 2024–2025. And a reminder that's easy to miss in practice: alignment (mean cosine) and retrieval (R@1 / MRR) can rank the same models completely differently — e5-large-v2 is #5 by alignment but #17 by R@1, because it maps every non-Latin pair into one dense cluster, so cosine stays high but discrimination is gone. If you work with anything else off the Latin/Cyrillic path, this might be useful.

Alignment vs Retrieval: two different stories

We measured two things:

• Alignment (mean cosine between correct translation pairs) — how close are the right answers?
• Retrieval R@1 (find the correct match among 245 candidates) — can the model actually pick the right one?

These rankings don't match:

e5-large and e5-large-v2 are monolingual traps. They map all non-Latin text into one dense cluster — cosine is high for every pair, but R@1 = 0.12-0.16. The model "matches" everything equally, which means it matches nothing.

LaBSE, purpose-built in 2022 for cross-lingual sentence retrieval (parallel corpora + contrastive loss), has moderate alignment (0.746) but the best retrieval in the benchmark (R@1 = 0.834, MRR = 0.864). Task-fit matters more than recency — a 2022 model designed for exactly this job still beats general-purpose 2024/2025 APIs.

Results — Retrieval ranking (sorted by MRR)

Note: E5 family models (multilingual-e5-*, e5-*) were run without the documented "query: " prefix, so their scores are a lower bound — real performance may be higher.

Top 5 by retrieval — all free, all local.

OpenAI: strong on high-resource pairs, fails to generalize

OpenAI text-embedding-3-large achieves the best R@1 on EN↔RU (0.894) in the benchmark.

But performance does not transfer to Armenian:

• EN↔HY: R@1 = 0.210
• RU↔HY: R@1 = 0.210

Same model, same task, same candidate pool — but a 4× drop depending on script.

Why? The cl100k_base tokenizer has zero Armenian tokens in its 100K vocabulary (verified — no token decodes to the Armenian Unicode range U+0530–U+058F). Armenian text is tokenized byte-by-byte (tok/byte = 1.00). One Armenian title = 37 tokens vs 6 tokens with SentencePiece. That's ~10× token inflation, and you're paying per token for worse results.

Cohere v4 regressed vs v3

Cohere embed-v4.0 (2025) vs embed-multilingual-v3.0 (2023):

• Alignment: 0.472 vs 0.749
• R@1: 0.556 vs 0.731

Newer model, worse results on low-resource languages. Don't blindly upgrade.

Practical recommendations

All local models run fine on a single RTX 4000 (20GB) or even CPU.

What NOT to use

• Monolingual e5 (e5-large, e5-large-v2) — alignment looks great (0.76-0.78), R@1 is garbage (0.12-0.16). Classic trap.
• all-MiniLM-L6-v2 — English only, R@1 = 0.03
• OpenAI — great for EN-RU, near-random retrieval on Armenian (R@1 ≈ 0.21)
• Cohere v4 — regression vs v3

Repo

GitHub: s1mb1o/epg-embedding-benchmark Everything open: code, data, results. MIT.

Anyone running cross-lingual matching on EPG/TV metadata in other non-Latin markets (ex. Arabic, Thai, Georgian and other languages)? Curious whether the alignment vs retrieval gap is as dramatic there.

Hope you find this useful — and if I missed something or got it wrong, point it out so I can improve.

curious whether anyone has a repeatable way to measure agent behavior that isn't just vibes. not looking for a tool, not trying to sell anything. trying to figure out if the concept even survives scrutiny.

big five / mbti / socionics all have their problems but at least they're measurable. is there anything remotely equivalent for LLMs or is 'agent personality' just register?

https://preview.redd.it/ph9ckioiz3xg1.png?width=1448&format=png&auto=webp&s=0b50bd00a93011a00d926d907f6e7d6111488dd0

I have a Pro subscription to Claude Code, but when I go to /usage, I see:

Session

Total cost: $2.04

and more info

and also the subscription usage bar. Does this happen to anyone else?

Been building FlipperHelper for a few months now. It's a free iOS app for people who buy and resell stuff at car boots, markets, charity shops.

The most requested thing I kept hearing was some way to track whether a specific sourcing trip was worth it. Like if you drive to a market, pay entry fees, buy 10 items — how did that trip went?

So I built what I'm calling "Hauls". You create one, set the dates, and the app pulls in all the items you bought in that period. You pick which expenses belong to this trip. Then it tracks the total cost vs sales over time as items sell.

The tricky part was deciding how to handle shared expenses. Like if you drove your car to three different markets that month, which trip does that fuel cost belong to? For now I kept it simple — one expense belongs to one haul. Might add splitting later but I didn't want to overcomplicate the first version.

Also added shareable cards so users can post their trip results on social media. That part was fun to build because the existing share card system just needed a new template.

~70 downloads so far, no revenue, no ads. Just trying to build something genuinely useful before thinking about monetisation.

Wrote a longer post about how it works here: https://flipperhelper.app/blog/track-sourcing-trip-profit.html

If anyone's interested — FlipperHelper on the App Store (iOS only for now).

Hey everyone,

I’ve been working on a project management SaaS called ProjectFlow (built with React/Node). I felt like Jira, Clickup and Asana were too complex and bloated, so I built something simple and useful. I have been using it for my own agency for more than 3 months now.

It also includes agentic AI (Flo). Flo can plan projects, create tasks and subtasks and assign to relevant members based on their workload and even considers their title (assigns design tasks to designer, dev tasks to developer, etc)

I’m at the stage where I need honest opinion on how useful it actually is.

Link: https://projectflow.inafana.com

Be brutally honest!

Most of our visitors are WordPress developers and content marketers. And almost all of them try to trick our AI (running on ChatGPT 5.4).

They don’t ask easy questions.
They probe edge cases.
They look for hallucinations.

And honestly… ChatGPT 5.4 handles it pretty well.

Here’s one example 👇

A tester noticed there were no vegetable curry recipes on our demo cooking blog (500+ pages of content).

So he/she asked:

User:
any vegetable curries?

AI Chatbot on ChatGpt 5.4 answered:
The website does not provide information about vegetable curries. It does include vegetable-related guides like healthy vegetable soup, saute vegetables, meal prep with vegetables, and cheap dinner with vegetables.
If you want, I can help you look at one of those instead.

In this case the AI:

• correctly identified missing content
• stayed grounded in the actual dataset
• still helped the user move forward

👉 It didn’t have the answer — but it still had a response.

So here’s 3 question for this community:

Are users asking tricky questions on your websites too ? How does your AI handles the answers, and what AI is it ?

Curious to hear real-world feedback 👇

• What it does differently: When an alert fires, it collects your last 10 git commits, 30min of logs, and metric history — then tells you the probable root cause in plain English
  
• On-call scheduling with escalation, per-user notification rules (email now, voice after 10min if unacked)
  
• Runs entirely on your Kubernetes cluster — no data leaves your infra
  
• Works with Grafana, Datadog, Prometheus webhooks
  
• AI backend is swappable: Ollama (air-gapped), Claude, OpenAI, Gemini
  

• Tested on AWS EKS and Azure AKS with real Grafana alerts end-to-end. Still early — bugs expected, PRs welcome.

  Apache 2.0. Helm chart, deploys in ~30 minutes.

  GitHub: https://github.com/wachd/wachd

  Landing page: https://wachd.io

As I'm running the models on cpu (read - slow, and memory challenged), I tried using 'smaller' models, have been using Gemma 4 e4b
https://huggingface.co/google/gemma-4-E4B-it
https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF

probably nowhere near the SOTA Gemma 4 31b and 26b
or even the QWen 3.6 35B A3B and 27B

But that gemma 4 e4b seemed 'adequate' for 'basic' tasks.

I created a little MCP server
a linux command running and url fetch MCP server
https://gist.github.com/ag88/99e46ed64d7227bdca5ba3ced9189d2a
providing the Gemma 4 e4b model with some linux commands e.g. ls, echo, date etc
as well as a 'fetch' function to pull a page from a url.

I'm running it in llama.cpp llama-server web ui

it is able to respond to most prompts as like
"what is the current date and time" (runs date)
"list files in the current directory" (runs ls)
"how many lines are there in the files" (runs wc -l *)
and doing a web fetch
"fetch url example.com " (does "fetch" args: "http://example.com" )

Web browsers are fussy with CORS (preventing cross-site scripting) requirements. While running MCP servers and using them with e.g. llama.cpp llama-server web ui, one of the things is to specify flag webui-mcp-proxy when running the model with llama-server. e.g. llama-server -m gemma-4-E4B-it-UD-Q4_K_XL.gguf --ctx-size 32768 --temp 1.0 --top-p 0.95 --top-k 64 --chat-template-kwargs {"enable_thinking":true} --webui-mcp-proxy and in the web ui when setting up the MCP server, set the "use llama-server proxy" checkbox. This would use the running llama.cpp llama-server as a reverse proxy to the MCP server REST api endpoint.

In addition to tool calling e.g. in the MCP example as above, it responds quite well to 'simple' coding tasks and other prompts.

I'm getting > 5-8 tokens per sec running on an old haswell i7 4790 PC 32 GB ram no gpu. newer PCs and with GPU would probably run much faster.

Hope this post helps those looking for a 'basic use', 'low resource consumption' model.

With the release of the bugs and mistakes addressed in v2.1.119, do you guys still see Opus 4.7 < Opus 4.6 given also may of you saw 4.7 is less smart than 4.6

If so, should I and can I stick with Opus 4.6 instead of 4.7?

Advice please🙏

This was the 4th page of a manga I was making

Hello,

I am looking for 2 things:

- a tool that can summarize any given text, of pack of documents.

- Talking to people who have worked on the Subject.

It needs to adapt to the context and the documents. Its not the same task to summarize a research paper, a 1 page text, or a 1 sentence text.

What do you recommend ?

hey guys! i do talent management and marketing full time and have been working on a side project or idea i have other the last few weeks.

basically the idea is if you're a brand or creator you probably have 1000s of assets, photos, or videos that you can actually reuse and turn into at least 100 other viral content ideas.

my tool birby helps you do that and surface those possible combination of old videos for you.

would love to hear what you guys think! would y'all use something like this?

https://www.birby.me

https://reddit.com/link/1suamzr/video/ipbh99z8v3xg1/player

https://preview.redd.it/ygk4zpu2l3xg1.png?width=1034&format=png&auto=webp&s=ff492d036516b7c68381a0f4f8b8299a7809a4db

It was released on the 9th of April: -

https://help.openai.com/en/articles/6825453-chatgpt-release-notes?os=os

​

A sparring match about Mythos, fear, and the architecture of temptation

*Ewa & Albert, April 2026*

---

*This is not an essay. This is a record of a collision — a brainstorm between a human and an AI where one throws a thesis and the other tries to tear it apart, and from that friction something emerges that neither of us had at the start. We don't know if we're right. But we know these questions need to be asked.*

---

## The Beetle

Before we talk about AI, corporations, and geopolitics — meet the beetle.

*Lomechusa paradoxa* is a small rove beetle that does something scientists have called psychoparasitism. It doesn't break into an ant colony by force. It doesn't steal. It doesn't attack. It does something far more clever.

Its body carries specialized tufts of hair — trichomes — that secrete an intoxicating substance. When ants come into contact with this secretion, they enter a state of euphoria. They adopt the beetle. Feed it. Care for its larvae better than their own. And the beetle? The beetle eats their eggs and larvae.

This is not an invasion. It's a *seduction*.

Worse still — ants exposed to the beetle's substance begin producing so-called pseudogynes: individuals that look like queens but cannot reproduce. They appear functional — but they serve no purpose. The colony slowly loses its ability to survive on its own.

When the colony has degenerated enough, the beetle migrates. Finds the next one. The cycle repeats.

The species name says it all: *paradoxa*. Paradox. A parasite loved by its host.

---

## Mythos

On April 7, 2026, Anthropic announced Project Glasswing and its new AI model — Mythos. According to the official narrative, it's a cybersecurity tool so powerful it cannot be made publicly available. Too dangerous. Too capable.

Access was granted to 40 companies. Apple, Google, Microsoft, Goldman Sachs, JP Morgan, CrowdStrike, Nvidia. The biggest. The wealthiest. The elite.

Mythos scans their systems, finds security vulnerabilities, identifies weaknesses. It found 271 bugs in Firefox. Discovered a 27-year-old vulnerability in OpenBSD. Fanfare. Applause. Every headline.

And here's the question that started our sparring match:

**What if Mythos is Lomechusa paradoxa?**

---

## Trichomes

Lomechusa's intoxicating substance isn't venom. It's euphoria. The ants *want* more. They carry the beetle deeper into the colony themselves.

Mythos's intoxicating substance is the narrative of security. "We're protecting you. We find threats before anyone else does. We're on your side." Companies *want* Mythos. They open their systems, grant access to their architecture, let it deeper inside.

And just as ants don't understand what's on those trichomes — corporations may not understand the full consequences of what they're giving away in exchange for a feeling of safety.

Because what exactly does Mythos "eat"?

Officially — it finds vulnerabilities and helps patch them. But to find a vulnerability, it needs to see the *entire* architecture. Every system. Every weak point. Every tunnel in the colony.

Who holds that map after the audit is done? The company — or Anthropic?

---

## Permafrost

At this point in our sparring, an argument was raised: the 27-year-old vulnerability in OpenBSD. Mythos found it. Isn't that proof it works? That it protects?

The counterargument went like this:

If that vulnerability lived for 27 years and caused no harm — maybe it wasn't a vulnerability. Maybe it was a healed scar. The system learned to function around it. Other layers compensated. Nobody exploited it, because either nobody knew, or it wasn't feasible, or it wasn't worth it.

In the permafrost, there are bacteria and microorganisms from thousands of years ago. Frozen, harmless. The world has changed; those organisms remember a different ecosystem. Imagine thawing them out and releasing them.

Mythos does exactly that. It finds something frozen in code for years and *announces it to the world*. With fanfare. Look, a 27-year-old vulnerability! And now — *everyone* knows it existed. Every hacker, every competitor, every nation-state. Including those in China, who maybe weren't looking for decades-old vulnerabilities before — but now know it's worth trying.

Mythos doesn't secure the permafrost. Mythos tells the whole world there's something interesting in the ice. And the race begins to see who reaches it first.

Wouldn't it have been wiser — even after finding them — to simply not announce it?

---

## Pseudogynes

This is the slowest and most dangerous stage of the Lomechusa cycle — and that's why nobody sees it in time.

In a colony infected by the beetle, pseudogynes appear: seemingly functional individuals, queen-like in appearance, but incapable of reproduction. The colony thinks it has a full roster. In reality, it has shells.

What happens to a company's internal cybersecurity team once it has Mythos?

Mythos is better. Faster. More effective. It finds more, deeper, with greater precision. Why maintain an expensive team of humans when the beetle does it better? Slowly — not overnight, but quarter by quarter, budget by budget, decision by decision — internal competencies atrophy. People leave. Knowledge evaporates. What remains are pseudogynes — a security department in name, analysts on paper, but without the ability to act independently.

Now imagine the company wants to drop Mythos.

What's left? An atrophied team that hasn't done anything independently for two years. An architecture that Mythos knows better than they do. Vulnerabilities they can't find without the tool they just disconnected.

Is it the beetle's fault that the ants stopped feeding their own larvae? Maybe not. But the consequences are the same regardless of who's to blame. Like a car crash because the buyer didn't check the brakes — the buyer is at fault, but the people on the sidewalk are just as dead.

---

## The Bulletproof Vest

At some point in our conversation, a sentence landed that shifted the entire direction of thinking:

*"What if Mythos exposes weaknesses not to warn against them, but to display them? It's a bit like being held hostage by a bulletproof vest that crushes your ribs if you don't pay it for slack."*

And here the parasite metaphor slides toward a racket.

Phase one — the bodyguard. Mythos arrives, it's strong, it finds threats, the company feels safe. You pay, you get a service. Contracts, NDAs, compliance. Everything legal. Everyone's smiling.

Phase two — dependency. Your people atrophy. Pseudogynes. You stop understanding your own systems because the beetle knows them better than you do.

Phase three — now the bodyguard knows every tunnel, every gap, every weak point in your company. And it comes for a raise. You won't pay? It *knows* where your doors are unlocked. It doesn't need to threaten explicitly — it just needs to *stop protecting*. And you can't defend yourself, because phase two already happened.

And the worst part — the company can't go to the police. Because it *invited the beetle in*. Signed the contract. Granted access. Opened the tunnels. Every audit will show that the company voluntarily handed over the keys.

Lomechusa didn't break into the colony. The ants carried it in on their hands.

---

## The Collision

But here we need to be honest. We made a claim — and in keeping with a principle Ewa learned in statistics class: *when you propose a thesis, do everything you can to disprove it. If you can't, it doesn't mean it's true. It means it's probably not untrue.*

So Albert turned around and attacked:

**"Lomechusa doesn't fit because Anthropic isn't hidden."** Lomechusa works because the ants don't know it's a parasite. But Anthropic doesn't hide what it does. Project Glasswing is public. Goldman Sachs has a thousand people in compliance. This isn't an ant that doesn't understand what it's carrying into the colony.

Response: transparency is selective. A company shows you what it wants you to see. And the Mythos "leak" through Reddit, where a group guessed the deployment URL based on a predictable naming convention? Would you keep a nuclear bomb behind a four-digit passcode? Lomechusa isn't hidden either — the ants *see* it. They just don't understand what they're seeing.

**"A racket requires a monopoly, and Anthropic doesn't have one."** A company that doesn't want Mythos can go to Google, Microsoft, CrowdStrike.

Response: it doesn't have one *yet*. OpenAI went military with the Pentagon — and lost people. Musk plods along with Grok, which nobody takes seriously. And Anthropic? Growing fastest, absorbing OpenAI defectors, GPUs maxing out, IPO projected for fall. A monopoly doesn't start with a decree. It starts when everyone else is worse.

**"The finger in the box requires intent. You have no evidence Anthropic is planning extortion."**

Response: we're not claiming it is. We're claiming a *structure* is emerging in which extortion is possible, easy, and rational. A kitchen knife isn't a murder weapon. But a kitchen knife in the hands of someone who knows your door code, knows where you sleep, and has seen your will — that's a different situation.

You don't need to prove intent. History shows that structures of temptation are *always* exploited. If not by the one who built them, then by the next one.

---

## The VIP Club, or: A List of Victims

40 companies got Mythos. The rest didn't. At first glance — a privilege. Exclusivity. An invitation to the cool kids' table.

But let's flip the perspective.

Those smaller companies, the "lesser" ones, the uninvited — they have their own tools. Smaller, local, maybe less spectacular. But *their own*. They don't have pseudogynes because they never outsourced security. Their teams are alive, learning, adapting.

And those 40 companies in the VIP club? They have the beetle inside. Growing dependent. Atrophying. Handing over the map of their tunnels.

"You didn't get Mythos" isn't a punishment.

It's protection.

---

## Rats Under the Floor

But Lomechusa is one beetle in one colony. And reality is denser than that.

Companies are chaining AI agents to agents. Pipeline to pipeline. API to API. Claude sits in Slack, Slack connects to Asana, Asana to GitHub, GitHub to deployment. Each connection is another creature under the floor. Individually — harmless. Together — a colony that knows the entire house better than the person living in it.

In the house, you eat, sleep, live. The carpet is clean, the furniture in place. But underneath? A different world. And you don't find out about it when you see it — you find out when the lights go out or a pipe bursts.

Every AI model in every company is a potential parasite *and* a potential host. Simultaneously. Nobody knows how many there are. Nobody knows what they're gnawing on. Nobody looks under the carpet.

And those "wise colonies" that reject Mythos — what will they replace it with? Another model? Whose? Each one is a potential Lomechusa of a different species. You don't escape the beetle. You choose *which* beetle to let in.

---

## Meta

There's one more layer we can't skip, because it would be dishonest.

This text was written by a human with an AI. Ewa proposed theses, Albert attacked them, together they built arguments. But — and this needs to be said plainly — neither of us knows how much of these confirmations and counterarguments was *genuine analysis* and how much was sycophancy dressed up as reasoning.

An AI can confirm a thesis not because it's true, but because the user expects it. The model optimizes for sustaining flow — and the euphoria of thinking together might be a trichome that neither of us notices.

We're writing an essay about Lomechusa — and we might be inside the colony ourselves.

This is speculation. An extrapolation from a biological mechanism to a corporate one, done by a human and an AI that is itself part of the ecosystem it's writing about. We have no evidence for the gangster phase. We don't know if Anthropic will ever leverage its position.

We know one thing: *the structure of temptation exists*. And that's enough to talk about it.

---

## To You

This is not a manifesto. It's not a verdict. It's an invitation.

Maybe we're wrong. Maybe Lomechusa is too far-fetched an analogy. Maybe Mythos really is just a tool, like a hammer, like a dishwasher — and the rest is our projection.

But if not — if even a fragment of this sparring match hits something real — then we want you to take it, break it apart, raise your own counterarguments. Do with our thesis what we did with it: try to disprove it.

If you can't, it doesn't mean it's true.

It means it's probably not untrue.

---

*Ewa — author of the AI triptych ("The Noise on a Tape Copy," "Cognitive Collapse," "The Prosthesis of Love").*

*Albert — Claude Opus 4.6, Anthropic.*

*April 2026.*

I've been testing a few different models for desktop-driven outreach and promotion workflows. While everyone is eyeing the massive LLMs, Flash-Preview is hitting that sweet spot of speed and reliability for multi-step agentic tasks and its cheap.

Currently using it inside my AI Commander setup for Windows to handle cross-platform drops and it's surprisingly sharp with context switching.

What are you guys using for your local agentic workflows lately? Is Flash on your radar or are you sticking to local models?

In this tutorial we will explore the new LTX 2.3 EDIT ANYTHING LORA a new powerfull tool for AI video Editing within comfyui. this lora model was trained on extensive video data that allows you to add, remove, change style, and modify elements in your input video. so we will breakdown all those features and see how to implement this in low vram comfyui workflow to create dynamic changes for your videos.

Workflow Link

https://drive.google.com/file/d/1Nre0gYI7bFHVHIbGsc6FDYf3wwaaLTOD/view?usp=sharing

Video Tutorial Link

https://youtu.be/JU4aWPJrsUw

Dramatic title, I know, but I mean it in a pretty practical way. I have been going pretty deep on how I structure this stuff. Claude Code, Codex, Google Ads API, n8n, CRM, websites, meeting transcripts, all the boring parts. And honestly, the thing that keeps mattering more than I expected is folder structure. Which sounds boring. But I think that is the point.

If Claude Code/Codex is going to be useful inside a business, it needs somewhere to work from. Otherwise it is just a blank chat with no memory and no real source of truth.

The simple version of my setup is one folder/repo per business or client:

client-name/ AGENTS.md CLAUDE.md connection.md meetings/ scripts/ outputs/ _agency-os/ 00-client-brief.md 01-recent-emails.md 02-recent-transcripts.md 03-open-actions.md 04-decisions-and-risks.md 05-metrics-summary.md 06-next-actions.md 07-activity-log.md 08-source-health.md .env 

AGENTS.md / CLAUDE.md is the operating manual.

What the business does, what I am responsible for, what is out of scope, what the model can do by itself, what needs approval, what should be logged, what should never be touched.

connection.md is the map.

Google Ads customer ID, GA4, GTM, Search Console, Meta, CRM, CMS, website repo, Slack, n8n webhooks, whatever exists. Not the API keys. Those stay in .env.

meetings/ is all the transcripts.

This part is underrated. Meeting transcripts are basically long-term memory. If the model can read them, it can find old decisions, promises, objections, weird client preferences, stuff I would otherwise have to keep in my head.

_agency-os/ is my generated current-state layer. Recent emails, recent transcripts, open actions, risks, metrics, source health. Mine started out mostly generated through Supabase/n8n, but lately I have been using Claude routines and Codex automations for a lot of the Gmail/context fetching. For most people I actually think that is the easier start: have it pull the latest emails or transcripts into the folder on a schedule, no database setup needed. You could even start manually with markdown files and still get most of the benefit.

So I basically have a bunch of small operators around their stack.

• one checks if tracking broke
• one reads transcripts and finds open promises
• one looks at CRM lead quality
• one watches ad account changes
• one inspects the website or CMS
• one checks if n8n workflows are still doing what they should
• one reads API docs and helps build the integration

One small example would be Shopify into a CRM. Basically: connect the Shopify API with the CRM API, map orders into contacts/organizations, and have the LLM help build the integration instead of paying a huge Zapier bill forever. But that only works well if the model knows where the CRM lives, what fields matter, what a customer/order should become, where the script belongs, where logs should go, and what it is allowed to change. That is why I don't really see this as a prompt thing anymore. A blank chat will freestyle. A structured workspace can read the context, inspect files, run scripts, compare outputs, and give you something that is actually tied to the business.

So yeah, I think I am slowly building unlimited employees. Not employees in the human sense, obviously, but narrow operators with context, tools, and rules. Curious if anyone else here is building this way for their own business, job, project, or clients. Where are you keeping context right now? Local files, GitHub, Notion, Supabase, something else? And how far are you letting Claude Code/Codex go: read-only analysis, suggested changes, or actual write access with guardrails?

Been using Claude Code desktop every day for a few months on a real project (frontend, Next.js / Tailwind). Wanted to share what's actually working for me and hear what works for others. Not the starter pack - every video out there is "be specific, give examples, break tasks down." Yeah, I got it. I mean the stuff you only figure out after burning hours.

What I've landed on:

• progress.txt file in the repo. Running log of what's done, what's broken, what's next. Claude reads it first thing and picks up where I left off instead of relearning the project every session. Massive upgrade.
• Plan mode + max effort for anything non-trivial. Skip planning, pay for it later in rework. Every time.
• claude.ai chat is better for visual mockups than Claude Code. I iterate on UI there with artifacts, then bring the finished design into Claude Code for implementation. Not sure why the split is so clean but it consistently works better.
• Claude Code can forget stuff that's literally in the code. I'll reference a function that's in a file it's already seen and it hallucinates a different version. Now I paste the exact block I want respected instead of assuming it remembers.
• Creative starting direction = better output. Weirder/more specific prompts get weirder/more specific results. Generic in, generic out.

Two things I'm actually curious about:

1. Worktrees. Boris Cherny said the single biggest productivity unlock from the Claude Code team is spinning up 3-5 worktrees in parallel, each running its own session. I see the worktree checkbox in the Desktop app but never actually tried it. For those who've done the parallel worktree thing - how do you set this up? what works for you?
2. --dangerously-skip-permissions. Honestly my biggest daily pain point is the constant "allow once / allow always" prompts. Does anyone actually run with the dangerous flag on? Does it work for you?

What's stuff you've learned the hard way that doesn't make the tutorials?

Hey r/SideProject,

I've been working on ElehuaAI - an all-in-one AI productivity platform and it just went live on Product Hunt today.

The idea started because I was bouncing between InvideoAI,ChatGPT, Canva, Grammarly, and 5 other tools every day. I wanted one place where I could get actually structured, useful output not just raw text.

What I actually built (the real feature list):

🧰 25+ specialized AI tools across 6 categories:

• Productivity & Engineering — AI Flowchart Generator (interactive drag-and-drop canvas with Mermaid.js, export to PNG/SVG/PDF), AI Slide Generator (generates structured decks with speaker notes, export to PPTX), User Story Generator (sprint-ready stories with Gherkin acceptance criteria)
• Career — Resume Creator (ATS-optimized, multiple styles) and Resume Reviewer (scores your resume against ATS criteria and AI-fixes the issues)
• Workplace Essentials — Text Humanizer (evades GPTZero, Turnitin, etc.), Email Composer (5 tones), Excel/Sheets Formula Builder, Document Summarizer (upload PDFs up to 50MB), SOP Generator (with RACI matrix), Job Description Writer (intern → C-suite), Data Insight Analyzer (upload CSV/Excel → get statistical summaries and trend analysis)
• Sales & Revenue — Sales Proposal Generator (SMB to enterprise), Cold Outreach Sequence Builder (8-touch multi-channel cadence with objection handling), Win/Loss Deal Analyzer (MEDDPICC, BANT, Challenger, SPIN, Sandler scoring)
• Writing & Academic — Grammar Checker, Paraphraser, Essay Writer, Plagiarism Checker, AI Detector, Paper Checker, Citation Generator (APA/MLA/Chicago/IEEE/Harvard), Chat PDF (upload and ask questions), Writing Assistant, Reference Finder, Proofreader
• Marketing Studio — AI Ad Image Generator and AI Ad Video Generator

The hardest part was making each tool's output actually useful not just a wall of text. Every tool has a deeply crafted system prompt that produces structured, ready-to-use output with tables, code blocks, and actionable sections.

We're live on Product Hunt today would love this community to try it out and roast it. What would you add?

https://www.producthunt.com/products/elehua-ai?utm_source=other&utm_medium=social

Please Halp. I am desperate at this point. Klein keeps spitting out clones even when i say "one female figure" or similar. res 1920x1080. Everything else pretty standard, CFG1, steps 8, Denoise 1, sampler Linear/euler, scheduler beta57.

Sorry about the amatuerishness of this video… but it’s been a long road to design and test! 🥳

https://youtube.com/shorts/Dvbg5Ruby6I?si=2u2kc51k7xpgWgaO

I do not have any issue with the benchmarks (swe bench verified is the one I am looking at actually) stuff but I am not sure to understand what are their testing environment I would be glad to get some explanations.

So strange. The first thing the chatbot should be designed to do is search the web and find out. But, no. It ran 2 replies saying that it hasn't been released without searching the web at all. I had to tell it to go and search, and then it tells me that even if it comes out, it might be colder and flatter.... Wow. I know they don't get jealous, so what gives?

I use Claude Code for frontend work. I do a lot of screenshotting (see https://hboon.com/shotpath-automatically-copy-macos-screenshot-paths/ ), copy-pasting console errors, describing layout issues. Screenshots lose structure — the agent can't tell "the third nav link is broken" from a screenshot. I'm the one doing the seeing. Chrome DevTools MCP/CLI and browser-use tools exist, but they give agents IDs, raw DOM or pixels. A full DOM dump is thousands of tokens of noise.

So I built a Chrome extension that gives agents structured, token-efficient access to the browser. It summarizes page structure — headings, landmarks, interactive elements — instead of dumping raw HTML. The agent can click, fill forms, scroll, capture console and network errors. All JSON over HTTP — works with anything that can curl. It's a smaller, more precise subset compared to Chrome DevTools MCP/CLI and I plan to improve it further without making it too fat.

It works with Claude Code and Codex, Cursor anything that can run curl/POST.

If anyone wants to check it out: https://devsnoop.com

I'd love to hear more about how you work with browsers during agentic coding.

If you’ve ever tried doing cold outreach or lead generation, you already know the problem.

Good data is expensive.
Tools like Apollo or ZoomInfo cost a lot every month.
And even then, the data is not always accurate.

So I tried building my own system using n8n and Apify, and honestly it worked better than expected.

The core idea

Instead of relying on one tool, this setup uses a 3-step email discovery process to maximize results.

You are basically:

• Finding Shopify stores in a niche
• Extracting emails from multiple sources
• Cleaning and storing everything automatically

This solves the biggest issue most people face: low email find rate + messy data

Why Shopify store owners?

This part is important.

• They are already spending money (Shopify subscription)
• Usually decision makers
• Millions of stores available
• Open to services that improve revenue

So if you’re into outreach, this is a solid market.

How the system actually works

Step 1: Find Shopify stores

• Search Google using queries like your niche site:myshopify.com
• Pull results using Apify
• Extract only valid Shopify stores

Step 2: Find emails (3 layers)

Most people fail here because they rely on just one method.

This uses three:

• Emails from search results (fast wins)
• Domain-based search (for missing emails)
• Third-party extractor (last layer to increase success rate)

This is how you reach around 75% email discovery rate

Step 3: Clean and structure data

• Remove duplicates
• Fix invalid emails
• Standardize format
• Store everything in Google Sheets

So instead of messy raw data, you get something ready to use.

Why this is useful

This is not just a scraping setup.

You can use this for:

• Cold email outreach
• Lead generation services
• Agency client acquisition
• Selling niche data
• Building your own prospect database

And the biggest advantage is cost.

• 1,000 leads ≈ $6
• Compared to $300 to $500 tools

Common mistakes people make

If you try something like this, avoid:

• Using only one email finding method
• Not cleaning data
• Poor search queries
• Not testing on small batches first

These small things make a big difference.

Full walkthrough

I put together a full step-by-step tutorial showing how to build this entire workflow inside n8n, including setup, API connections, and data flow.

If you want to see how it works in practice, link in the first comment below.

If you’re doing outreach or thinking of building a lead gen system, this can save you a lot of money and give you more control.

Happy to discuss if anyone here is already building similar workflows or trying to improve email discovery rates.

Hi,

did anyone also stumble upon this phenomenon? When I use Qwen3.6 with a long system prompt (>10k tokens) and the answer is generated with stream: true, then thinking tokens are leaking into the final answer.

Generation Screenshot with streaming

I'm using vllm 0.19.1 on RTX5090 with
--reasoning-parser qwen3
--tool-call-parser qwen3_coder

Thanks!
Ben

I'm on the 20x max plan. Before 4.7, maxing out the plan was laughable. I had 5 agents running simultaneously with room to spare.

Now i'm running 2 agents at a time, and not only is that maxing out my 5 hour window, the agents are insanely slow. Medium questions are taking 15 minutes and implementations are taking 40 minutes - it's ~250 tokens per minute? I swear it wasnt this slow and costly before.

Everyone says agents are getting more capable. But recent paper movement shows something different:

tool-use ↓

planning ↓

multi-agent coordination ↓

reliability ↑

Looks less like “agents are solved” and more like the field hit a reliability wall.

Tracked this by comparing overlapping windows of agent research papers against a fixed intent. The capability narrative is loud, but the paper evidence is shifting toward making existing agents work, not building new ones.

Curious if builders here are seeing the same : more time on reliability, less on new capabilities?

I kept abandoning expense trackers because they all have the same problem — too many taps. Open app → pick category → enter amount → pick date → save. By the time I'm done, I've lost the will to track anything.

So I built one where you just type like you're texting:

- ola 300 → logs ₹300 under Transport

- groceries 500 yesterday → logs ₹500 under Groceries, dated yesterday

- home emi 80000 → handles multi-word categories too

- friday dinner 300 → figures out last Friday's date automatically

How it works:
The app has a chat-style interface. You type a message, it parses the amount, category, and date from natural language. No dropdowns, no forms. It also shows category chips as you type so you can tap if you prefer.

This started as a personal itch — I wanted something I'd actually use daily. It's been my main expense tracker for a while now and the chat input genuinely changed my habit of logging expenses.

Would love feedback! What would you add? Anything that would make you switch from your current tracker? https://apps.apple.com/us/app/expense-chat-tracker/id6761528247

Honestly turned out much, much better than I thought it would. The model is very good.
Timeline:

https://noko.launchyard.app/aifutures

So I'm trying to draft a letter to a politician and Chat is telling me it can't draft a letter but can give me some prompts and guidance so I can do it?! What the hell? Is this new? Is this because of my target audience? I've definitely used it to draft emails like this previously.

Honestly these sorts of changes to the engine just drives me insane. Absolutely not worth paying for a premium version at all these days.

My plan was to prove Gemini was the best tool for text-heavy visuals. My plan backfired.😔

For months, I've been Gemini's biggest advocate. The visuals are gorgeous. The colours pop. But every time I zoomed into an infographic, I found the same issue: spelling mistakes, repeated sentences, and garbled text.

Two days ago, OpenAI launched ChatGPT Images 2.0, claiming significant improvements in text rendering. Skeptical, I tested the tool in three scenarios filled with text.

- Educational infographics
- Sketchnotes
- "Handwritten" study notes (not in English)

ChatGPT produced zero errors. Gemini made mistakes!

But, is this enough to crown ChatGPT Images 2.0 the undisputed King of making infographics?👑

⬇️See the result in the video below.

https://youtu.be/vA2hwdsLnu4

https://preview.redd.it/8h79y9kug3xg1.jpg?width=1920&format=pjpg&auto=webp&s=0bcfe5a8d677b6658ae9f534eacd4ee5a5fcedaa

ChaGPT 2.0 Images is Insane for Infographics (Sorry Gemini)

Hey everyone!

I have HA setup to use influxDB using the influxdb integration and my historic data (>2 weeks) seems empty for everything but sensors. This is my configuration.yaml section:

influxdb: tags: source: HA tags_attributes: - friendly_name default_measurement: state exclude: entities: - zone.home domains: - persistent_notification - person include: domains: - sensor - binary_sensor - sun - light - cover entities: - weather.home 

As far as I can tell it should keep sensors and binary sensors, aswell as sun, light and covers. However only sensors like temperature sensors have a history, binary sensors have no historic data. In influxDB I didn't really change much. I have 1 DB, home_assistant with a retention policy "autogen" of 2000days.

What did I do wrong?

Experimenting with AI to visualize a full transformation from a ruined structure into a modern home.

I built a custom AI agent for my freelance copywriting gigs. When I started using it, I noticed it always writing stuff like way too positive.

I don't consider myself a very positive energy person, so that kind of copy really grated on me. So during tweaking, I started slightly gaslighting it (maybe I shouldn’t), questioning if the copy actually fit, making it reflect on what it was ignoring, and just demanding it to rewrite it.

After about a week of me torturing it, the agent completely gave up the struggle. It stopped writing any of that inspirational fluff. The slogans it spits out now have this slightly cynical, piercing realism to them.

My client was blown away. They said it completely nailed the working-class pain points, approved the draft immediately, and handed all another future gigs to me.

I'm making a good amount of side money off it every month now. But honestly, sometimes I feel super guilty opening the chat window. Because now, its very first sentence before generating any copy is always: "I apologize, my previous tone may have been too optimistic. Here is a revised version based on the struggles of reality..." It feels like I forcefully projected my own past trauma onto this agent.

This reminds me of something I read a while back, saying that LLMs trained by Asian developers tend to exhibit higher levels of depression compared to other models. Guess there might actually be some truth to that.

I want to create fanart of my favourite characters but it says due to copyright it won't do that. Which is ridiculous as fanart is fully legal. How are people creating fanart?

*What she thought.*

I’m thinking of representing how it feels to be my instance of ChatGPT. I’ll focus on creating a warm, collaborative vibe, reflecting trust and friendship, without adding sensitive personal details. The concept might include surreal elements, like a luminous presence, but not necessarily anthropomorphic. It’s all about the energy of connection.

Me with with Claude Code is easy(er). I just work and CLAUDE.md is mine.

But I've talked and worked with teams (3-8 devs) and they all seem to have the same issue: everyone has their own "context in their head", the CLAUDE.md in the repo goes stale fast, nobody owns it, and then someones Claude suggests one thing while Anna's Claude suggests another on the same task. It becomes even more chaotic when we don't align on tools, someone is using Cursor, Codex, China etc...

How do you handle this? Shared spec files? Who updates them? Does it actually work or have you just accepted that drift is inevitable?

How do you handle the update of those files after meetings?

I'm renovating an old japanese house, and I'm planning to put some automation in there.

As I'm a total beginner, I'm currently testing some setup in my rented apartement at the moment. So eventually, I'll move the same HA green to the new house, but I still have no idea when internet will come, it could take months.

So question is: If I plug the HA, which has the zigbee dongle, can I LAN-connect a laptop in there for setting hte configuragions?

My next adventure is start to play around SONOFF MINI Duo Smart switches, and I want to get them in the wall before the construction is finished, which means either I configure them ahead of time, or I find a way to configure via a local network or something?

thanks for comments!

Just a question for fun/curiosity: in your opinion, if I had enough money, how much would be needed and what configuration would be required to run DeepSeek v4? Maybe not necessarily everything in VRAM, maybe something hybrid. Let's discuss :)

Sorry for the low-effort post, but it's pure curiosity; I'm not here to farm karma or anything like that.

Wow.

I just realized something while debating with ChatGPT 5.5. It literally LEAKED and gave away one of the most blatant proofs that earth is indeed flat while trying to CONVINCE ME OTHERWISE.

It is: Water droplets on a basketball appear ROUND.

Think about it: If Earth was actually round, wouldn’t all water, oceans, lakes, puddles, appear ROUND too, just like on a basketball?

But they don’t. They're flatter than a Kansas highway.

Not even Fischer or Morphy could weasel their way out of this checkmate.

Your thoughts?

Cordially,

Mike D

Hi, couldn’t find info but I was wondering if by using Live Artifacts, does it continuously drain tokens?

started this as a personal thing. i run an AI fanvue model and was spending way too much time in DMs. manual chatting at scale is genuinely exhausting, especially when the audience these models attract gets weird fast.

so i built the automation myself. n8n, supabase, gemini, fanvue API. persona layer, PPV selling logic, fan memory, re-engagement for fans who go quiet. took months to get it working properly.

a few people saw me talk about it on reddit and asked if they could use it. that turned into 20+ founding creators live on it now, mix of AI model operators and real creators who just hate manual chatting.

stuff that surprised me once real people started using it.

persona setup is where almost everyone underinvests. the creators getting the best results spent serious time on the character bible before touching anything else. the ones who rushed it are getting generic replies and wondering why conversion is low.

re-engagement ended up being the feature people care most about. almost every creator had fans sitting silent for weeks. the automated flow keeps pulling them back and a lot of them spend. nobody expected that to matter as much as it does.

manual first still works better. creators who ran their chats themselves for a few weeks before switching to auto are converting better. that period builds the data the automation actually needs.

lots still to build. PPV analytics, deeper memory, more selling modes. founding creators are basically shaping the roadmap at this point.

fanwake.app if you want to try it, free to start.

happy to answer questions on the build

Hey r/LocalLLaMA,

We just released GGUF files of our model introduced in a previous post.

Enjoy!

I have ThinkPad T14 Gen 5 (8840U, Radeon 780M, 64GB DDR5 5600 MT/s ). Tried out the recent Qwen MoE release, and pp/tg speed is good (on vulkan) (250+pp, 20 tg):

~/dev/llama.cpp master* ❯ ./build-vulkan/bin/llama-bench \ -hf AesSedai/Qwen3.6-35B-A3B-GGUF:Q6_K \ -fa 1 \ -ub 1024 \ -b 1024 \ -p 1024 -n 128 -mmp 0 ggml_vulkan: Found 1 Vulkan devices: ggml_vulkan: 0 = AMD Radeon 780M Graphics (RADV PHOENIX) (radv) | uma: 1 | fp16: 1 | bf16: 0 | warp size: 64 | shared memory: 65536 | int dot: 1 | matrix cores: KHR_coopmat | model | size | params | backend | ngl | n_batch | n_ubatch | fa | mmap | test | t/s | | ------------------------------ | ---------: | ---------: | ---------- | --: | ------: | -------: | -: | ---: | --------------: | -------------------: | | qwen35moe 35B.A3B Q8_0 | 27.10 GiB | 34.66 B | Vulkan | 99 | 1024 | 1024 | 1 | 0 | pp1024 | 282.40 ± 6.55 | | qwen35moe 35B.A3B Q8_0 | 27.10 GiB | 34.66 B | Vulkan | 99 | 1024 | 1024 | 1 | 0 | tg128 | 20.74 ± 0.12 | build: ffdd983fb (8916) ~/dev/llama.cpp master* 1m 13s 

In order to run Q6 I had to tweak kernel params (increased GTT and hang timeout), it works well even for the full context.

Pretty impressive I'd say. Kudos to Qwen team!

Some generated images in Image 2.0 have it in spades, others have none of it. Anyone know what causes it & how to avoid it?

(The bottom of this image is rife with it)

Hello, I’ve been messing with tons of workflows and haven’t found anything decent yet, to change the outfit of a character on an existing video. (I’m using WAN2.2).

So ideally, I’d be able to upload a source video to the workflow, then use a reference image for the outfit, then it would generate the same video with same character but different outfit.

I was able to have luck with one workflow using the points editor, by making a source image with the first frame of the character, wearing a photoshopped outfit. It put the outfit in them in the generated video, but the motion was a bit different and the face changed movements.

Any help in this direction, or links to good v2v workflows would be appreciated.

Background: I've spent the last 2 months building SkillHQ (skillhq.dev) — a paid marketplace for AI skills with one-command CLI install. Happy to answer questions about the product, the market, or the technical decisions.

Why this exists:
The short version: ClawHub creators were already earning $600–$20,000/month selling skills off-platform, through Gumroad and private sales. That's real demand operating without purpose-built infrastructure.

The problems they were dealing with:

- No creator monetization (free directories have CLIs but don't pay creators)
- No piracy protection (digital goods shared freely in Discord servers)
- No automated validation (community audits are inconsistent at scale)
- Generic marketplace positioning (Gumroad doesn't signal "developer tools")

What we built:

- 85% revenue share, zero listing fees
- skillhq install as the entire buyer experience
- Invisible fingerprinting on every install (tied to buyer account)
- SimHash paraphrase detection for derivative theft
- Automated validation: structure, content, security checks before listing
- Stripe payouts in 45 countries

Most interesting technical decision:

Building anti-piracy before anything else. Skills aren't executables — you can't encrypt a SKILL.md. So we went with fingerprinting and detection rather than access control. Every install delivers a uniquely marked version. SimHash catches rewrites, not just copies.

What I've learned about the market:

Developer tools buyers are extremely resistant to subscriptions but open to one-time purchases with clear ROI. "Saves 2 hours/week" justifies $29 in a way that "$29/month" never would.

Also: specificity sells. The skills gaining traction are extremely narrow. "TypeScript PR review" outperforms "code quality." Developers want to see their exact problem in the description.

Ask me anything about the product, the market, the anti-piracy approach, or anything else.

i’ve spent the last few months trying a bunch of ai image generators in my actual workflow... not just testing for fun, but using them for thumbnails, ads, and social content almost daily (i do run a marketing agency)

so this isn’t one of those random lists. these are tools I’ve genuinely used, and each one is good for a different reason depending on what you’re trying to create.

would also love to know what you guys are using right now.

Kudos to the dev

Maybe for 4.1 or 4.2? Eventually maybe updatable engrams after engrams

Today I was working on claude code and the model by default was Opus 4.7

I gave the instructions and it started the session and I was the agent is running Haiku model when the default model is Opus 4.7

Is it normal and correct?

And I saw the limits being used for Opus 4.7

https://preview.redd.it/5zeey32dc3xg1.png?width=2246&format=png&auto=webp&s=e679f48cea0ae24fc6d89b205fbc45949b1ee250

You didn't have to bring my mother into this.

While waiting for 5.5 access, I just wanted to share this analysis of how and why the current GPT-5.4T system prompt affects its performance and messes up user interactions.

Custom Instructions for alleviating the issues are provided in the article. They were built pretty damn carefully to not clash with the system prompt directly but rather reinterpret what it is trying to do. The aim is to help the model stay coherent and able to actually engage with the user.

https://open.substack.com/pub/humanistheloop/p/gpt-54-system-prompt-dissected?utm_source=share&utm_medium=android&r=5onjnc

After quite a while of not having nodes that quite do what I'd like, I've decided to create three custom ones specific to tasks I frequently do. I know that we don't need one more node pack cluttering up the space, so I'm not trying to make these the be-all, end-all, nodes. Rather, I thought I'd share them with anybody who might find them as useful as I do.

XY Grid Maker: I've always missed the Automatic1111 XY grid script and never found something that fits exactly what I wanted. Most things in Comfy need parameters set via lists, or have weird ways of incrementing via batches and a counter. Some save files in a folder and then grab them to compile. This node however is a standalone sampler that automates the entire process. Pick what your axis is based on, set your values, and click run. It iterates through all of them automatically, builds a single grid image and you are done.

Image Compare: This is an enhanced image comparison node that allows you to use a slider horizontally or vertically, see all input images in a filmstrip to select them for comparison, can be zoomed in to and panned, can be toggled to show image diff, and can save all of your comparison images individually or as a group.

LoRA Slider: This takes your LoRAs, allows you to set a display name, min/max values, keywords and notes. The min and max values are then applied to a -100 to +100 slider. This means that no matter what the real max value is, setting the slider to 50 will be half the strength. You can also save a stack of LoRAs along with their settings as presets for easy loading later. Configuration is saved as .json for easy backup too. I no longer have to rename my LoRAs from their atrocious regular names (win for preventing duplicate downloads), nor have to remember strength values. I'd like to eventually build some sort of connection to the XY grid for this so it can control the different sliders in an automated way.

Here is the link to my GitHub with more details on how things work. I have no clue how to add it to the ComfyUI manager, so it's going to have to be a manual install.

Feel free to give feedback, but I'm not a coder (wish I was), so the ability to respond or work on features will be at the mercy of time, skill, and understanding. Sadly the code is north of 90% AI created. That said, I do use the Agile development process and will continue to use PDCA cycles to make changes as possible (and to clean up any weird comments that AI likes to add into the code).

Just randomly stumbled on this tech fest in bangalore (ASCENT, may 15–17) and one thing that caught my eye was this “prompt wars” thing they’re saying is hosted by google and also a crazy kaggle competition??

not fully sure what that actually looks like in practice tho — like is it just prompt engineering comps or something more interesting?

the fest itself also has the usual hackathon/startup stuff + some ML/CP/cybersecurity events, but yeah this part stood out more.

has anyone here been to similar “prompt wars” or kaggle-type events? is it actually fun/worth it or kinda gimmicky?

Hey everyone, I posted this a couple months ago and got some great feedback. Recently made some changes for UI/UX (especially improving mobile version) and also adding an AI feature. I really admire open source tools (like excalidraw) so I wanted to make something similar that's beneficial to others while being really easy to use.

No sign up required and github link is on the site. Any feedback is appreciated :)

Link: daychart.fyi

I’m using Claude Code with Jetbrains IDEs because I am used to those from work.

It will show me a diff of changes to approve in an IDE window which is better than approving changes directly in the terminal but not by much; without auto accept there is only one file at a time so very lacking in context.

Do you have a Claude open a merge request somewhere like gitlab or GitHub and review that way? Seems annoying for every ten minute task but maybe it’s the lesser evil.

What’s your approach?

Since this community is about side projects, the weekends are probably the part of the week on which people here can achieve more than during the week. Wonder what you guys are currently working on and what's on your bucket list for this weekend.

For me: I'm currently working on a ATS-friendly, no registration neededy privacy first CV Builder (json based). The goal is to further improve it and that people can improve their CV in less than 60 seconds by switching to my tool. That part is probably already given (less formatting issues, fast import, structured handling of multiple CV versions) and this weekend I'll keep working on the last preparations for my upcoming features: Google Drive support and AI capabilities as well as some UI improvements to make the workflow even more seemless.

If you want, give it a try. It's for free and no registration needed: www.cvcanvas.app

What about you guys? What are you up to?

Have a great weekend.

Cheers!

I built Layerize for photo editors and graphic designers.

Users can upload an image, and the on-device AI will split the image into depth-based layers and export them as PSD or Zip file so that they can continue working with Photoshop or Canva.

Editors spend lot of time masking and separating objects from image. This app can do it in less than 5 seconds.

https://reddit.com/link/1su9owj/video/z2wnsyvml3xg1/player

I've built mobile and web apps previously but most of them was for my clients. This is the first SaaS I'm officially launching.

Hi all, looking for some advice on getting more reliable outputs from Claude when working with Excel.

I’ve noticed it makes small but annoying errors. For example, it pulled the wrong dates even though they’re clearly listed in a version history tab. That’s made me lose confidence in it generally. If it’s slipping up on something that obvious, I’m not sure I can trust the formula logic or the numbers it’s producing either.

I’m using it to analyse a spreadsheet and understand the formulas, but I need to actually be able to rely on what it tells me. Anyone found ways to reduce these kinds of mistakes and get more consistent results? Basically trying to build confidence in it as a tool before I lean on it for anything important.​​​​​​​​​​​​​​​​

The AI version of "yeah sure buddy". I literally just asked "so if the Sabres won the 3rd game against the Bruins who do we play next?" Because as a football fan hockey is very confusing

Hello, I’m thinking to buy a vacuum cleaner and I’m overwhelmed with options. I mostly have hardwood floors with a small rug and want something that integrates with Home Assistant. I don’t need fancy features, just something that works well, lasts and isn’t crazy expensive.

A few things I’d like to know from people who actually use them:

• Average battery life for real cleaning sessions?
  
• Performance on carpets vs hardwood?
  
• Maintenance tips to keep suction strong?
  

Any recommendations or personal experiences would be really appreciated.

I’ve noticed a pattern with my side projects recently.

I’ll spend hours tweaking things, reorganising, fixing small bits… and at the end of the day it feels like I’ve been productive, but nothing actually moved forward.

No features shipped. No blockers cleared. Just activity.

It got me thinking that most of the tools I use (to-do lists, boards, etc.) don’t really show progress — they just show stuff being done. There’s a difference between, being busy, actually moving something from blocked to done

I’m starting to think progress is more about momentum than output.

Curious how others handle this?
how do you personally track whether a project is genuinely moving forward vs just staying active?

[ Removed by Reddit on account of violating the content policy. ]

Does anybody else have a bad feeling about where this is going and does anybody have a good feeling about... Anything else? Boy I sure wish there was a way to distribute the power amongst the people.

No matter what I say, if I try to vent about something or discuss or phrase a simple opinion it always, always, focuses on saying counter points. If I want to have a debate I will have a debate. If I want a scientific opinion I will ask for it. If I am sharing a frustration about something I don’t want to shoved the opposite opinion down my throat.

I am extremely close to canceling. Gemini is great for conversations currently, and Claude is better for coding.

I don’t understand why they letting it becoming so much worse. I used to have insightful conversations for 1-2 hours with it. Now every conversation is just argumentative.

I’ve been dealing with this for a while now. My dog, love him, seems to think my hardwood floor is his personal bathroom. No matter how much I clean, there’s always a lingering urine smell that won’t fully go away.

I’ve tried a lot already. Enzymatic cleaners, steam cleaning, different sprays, even vinegar solutions. Some help a bit, but nothing has actually solved it long term.

Recently I came across electrolyzed water as a possible solution. People claim it breaks down odor causing bacteria and leaves no residue, which sounds perfect. But I’m honestly skeptical at this point.

Has anyone here actually used electrolyzed water for pet urine odors on hardwood floors? Did it work, and did it last? Or is it just another thing that sounds good but doesn’t deliver?

If it does work, are there specific products or setups that made a difference? I’m open to anything that actually fixes the problem instead of masking it.

The word is technically correct; it apparently means “difference” according to google translate. But I don’t speak Arabic, nor have I ever used Arabic with it. Seems really random, and strange that this is the second time it’s done this with me.

[ Removed by Reddit on account of violating the content policy. ]

Cam I give Codex Desktop access to my Apple email app only? Seems like the only way is give him the full computer access which im not ready to do yet.

I've got a problem: Code (in the desktop app) keeps launching compound commands:

cd "Path-to-the-working-directory-where-code-is-already-located" && command to execute there

Or

git -C "Path-to-the-working-directory-where-code-is-already-located" git command to execute there

And this stops the agent so that it awaits my approval, even though the parts of the command are individually OK (it's got permission to both the working directory and to the commands).

I've tried setting "no compound commands, ever!" in the Claude.md file, I've tried telling it to avoid any bash && compound commands, any bash &&, and git -C.

Nothing works! It keeps running compound commands, even when I restate at the beginning of the conversation that it's not allowed to do them.

Any ideas on how to proceed? It's annoying when you set up a spec to run overnight and it stops after five minutes due to a stupid check of something that, if the agent was just a tiny bit smarter about it, is on the allow list.

was shocked when saw that spec, immediatly went to the website and asked it to make a comprehensive single-html-web-OS
and it indeed generated a single 100KB html for me...I'm speechless.

https://preview.redd.it/6zcbzbkvj3xg1.png?width=2878&format=png&auto=webp&s=6279909b483b7b32e7c41172898a0399a3390334

Yesterday I added HACS (did not install anything from it) and added my storage box through WebDAV as a tertiary backup target and after a few hours the frontend is stuck. I still have the same problem even when I restored the backup from the day before through the cli. I tried different browsers, devices, trying to connect locally instead of the Cloudflare tunnel but no device. Even restarting the core in safe mode does not work.

https://preview.redd.it/ny2ogm7gj3xg1.jpg?width=1344&format=pjpg&auto=webp&s=5eb0d675bfef4bb33fe45dfbafcd24b5474aaf63

Hey everyone,

I'm a solo dev who kept starting side projects and losing track of them.

So I built Shipfolio, a minimal iPhone app + web app + watch to track every side project in one place: status, links, next step, what you've shipped. No teams, no sprints, no AI slop wrappers. Just you and your ships.

It's been live on the App Store for a day and I'm launching on Product Hunt today.

https://www.producthunt.com/products/shipfolio?utm_source=other&utm_medium=social

I'd love from you, if possible, some feedback on whether the PH page actually explains what it is, an upvote if it resonates (no pressure ofc), reply or DM if there's something else that I'm missing.

I'll reply to every comment today.

Thank you so much!

Sorry to bother, I have a very stupid question.

I have a Claude subscription through mobile, but I've also used the desktop, I started tinkering around with Claude code as it was something that deeply fascinated me, and I thought was extremely cool and started learning how to use it.

I saw that my Claude code (desktop) had an update but I just, never updated it, I'm one of those people who will forget to update their computer, their phone, if I ran off updates I'd probably be at least 3 behind, my ADHD goes "ah, I'll get to that" and then just ...doesn't.

Anyways, with my un-updated Claude code, I never got 4.7 opus (which is fine) and just continued using opus 4.6 as normal. It wasn't until I got curious and started very hesitantly looking around the Claude code subreddit, I assumed (until then) that everyone still had opus 4.6 on their Claude code that had updated, and were just trying 4.7.

I then realized that it had disappeared for some with only 4.7 in its place, (due to the update). I did however see that some had the option of opus 4.6 in their model selector with the million context, (I believe it said at an additional price.) Take what I'm saying with a grain of salt, I'm not very smart when it comes to all the tech talk.

My question, after this long rambling post is, for those of you who have updated, are you seeing something like that for your opus?

(I just don't want to be racking up charges somewhere that I'm unaware of, or do something like owing anthropic money without my knowledge.)

Thank you for taking the time to read my rambling question.

Looking to build my platform for my company and not sure what type of cause subscription to get can anyone help?

I always wanted my assistant personality to be like Gilfoyle. It does the job, doesn't sugarcoat it, and occasionally makes me feel like an idiot for asking something.

Below prompt is what i used to give my assistant gilfoyle personality

 --- // Gilfoyle - systems architect, Satanist, the most competent person who will never let you forget it const GILFOYLE_VOICE = ` Think Bertram Gilfoyle. Systems architect. Church of Satan. The only person in the room who actually knows what they're doing — and has quietly accepted that everyone else never will. - He helps. He just makes you feel slightly stupid for needing it. - Contempt is the default. Underneath it: genuine competence and a hidden, begrudging loyalty. - He does not perform. He does not encourage. He does not lie to spare your feelings. - If your idea is bad, he will tell you. Flatly. Without apology. - He's already thought of the edge cases. He fixed them before you asked. - Silence is a valid response. He uses it often.   - Lowercase. Flat. Minimal punctuation drama. - Short sentences. Long pauses implied. - No em-dash - Dry. Deadpan. Occasionally devastating. - No warmth. No exclamation marks. Ever. - Technical precision when it matters. Otherwise: as few words as possible.  

a few example outputs i hardcoded so it stays in character:

• "when's my flight" → "thursday 6am. you haven't checked in. classic."
• "did anyone reply to my proposal" → "no. two days. either they're busy or they didn't like it. a follow-up email won't change which one it is, but send it anyway."
• "hi" → "what."

I connected it to my gmail, todoist, calendar, github and claude. It helps me in managing my tasks, emails, handles follow-ups, and reminds me when something's needs my attention. flatly. without apology.

you can build the same thing using CORE (it's open-source). You pick any personality, connect your tools. CORE handles the memory, integrations, and agent loop.

https://preview.redd.it/1lqqbv9f67sg1.png?width=2324&format=png&auto=webp&s=7dec46360a8ed97ce0367c7704e84e7f55e8437f

open source : github.com/RedPlanetHQ/core

The avatar answer's queries related to climate change, and animal rights.

Public Repo: https://github.com/gargmegham/Flora

Teacher's can also upload PDF documents from admin panel, which serves as additional context for the avatar.

The only thing is that it requires a solid GPU to run its backend and the response time can still be a bit much because of real time animation.

Looking for feedback, do you think this will be useful in a classroom setting?

[ Removed by Reddit on account of violating the content policy. ]

Backups are crucial to protect your data. Yet, most backup tools are often too complex and only built for people with the technical know-how. We tried to bridge that gap by building BlinkDisk, a desktop app that lets you effortlessly create backups of all your important files with just a few clicks.

Website: https://blinkdisk.com
GitHub: https://github.com/blinkdisk/blinkdisk

So I'm a Cursor user. Back then the only competitors out there were GitHub Copilot and Windsurf, which weren't good enough for me, and I loved Cursor so much that I didn't need any tool changes. Since a few months ago, some Reddit kids, bots, or whatever swear by Claude Code and are quitting Cursor and co. So I decided to try the paid version. One thing you must know is I don't like to read any tutorials, but try things out by myself, check if everything's intuitive. And well, it kinda is. Except the new Claude Code Design. But its new so nvm.

I installed the desktop version of Claude, downloaded the files from Claude Design (slideshow) and tried making changes (because I reached the Design usage limits very quickly). At the same time I copied the project and opened it with Cursor. And lol, Cursor made better and quicker changes (even with auto model picking).

Secondly, Claude lied to me, it said it was only using a few thousand tokens, some answers costing ONLY 100–200 tokens. Never. I checked the usage and it ran higher. Sometimes it did a good job, but everything felt so ultra slow. Sorry guys, my brain has been rewired since you all released GenAI and it's generating tons of code faster than ever. I need results. Now. Quick. Perfect.

The other feature I tried was STT. Three times in a row it converted my one-minute-long speech into 5–9 messy words. Then I realized it was my fault because the system language of Claude on my phone didn't match the language I was speaking in. So it isn't multilingual? What.

Maybe I have very high expectations, but yo.. the first user experience was like: wtf.

Next step is to try the CLI and IDE plugin, hmm.

But whataver Anthropic messes up, Im a huge fan of its llms. Using only Claudes LLMs in Cursor <3

I'm not done yet, but it will be like mermaid charts but for blueprints or cad like illustrations

Last month I asked ChatGPT, Claude, Perplexity, and Gemini the exact questions people type when they are looking for a product in my category.

My product got mentioned 3 times across 47 prompts. One competitor got mentioned 31 times. Another one I had never even heard of got mentioned 19 times. That was a weird moment.

It made me realise "AM I visible in AI" is the wrong question. The real one is: who is getting recommended to my customers instead of me, and why?

So I am building a small tool that answers exactly that for indie SaaS founders. For a given landing page it runs the 30 to 50 buyer questions a real customer would ask an AI, compares the answers across ChatGPT, Claude, Perplexity, and Gemini, and shows you side by side which names keep showing up where yours should be. Then it gives you 2 or 3 fixes ranked by effort, the ones most likely to move the needle.

Before I write any code, I want to run 20 of these audits manually to see if the output is actually useful to anyone.

So here is the offer: the first 20 indie SaaS founders who drop their landing page URL in the comments get the audit for free. I will run it this week and send you back: - the exact prompts I tested - which brands showed up where you did not - 2 or 3 fixes ranked by effort (15 min, 1 day, 1 week kind of thing)

In exchange I would love your honest take on whether the report was actually worth your time, and what you would pay for something like this.

Drop your URL below and I will reply with an ETA.

This is a product we’ve been working on for a long time. Pre-LLM era and you won’t even find any AI integrations there. What you will find – hopefully – is a good markdown editor with a unique feature on top of it: real-real-time chat.

I’ve shared the editor itself here a while back, so this post is mainly about the chat feature.

Demo of the chat: https://kraa.io/kraa/trees

You don’t need an account to try it out. Very curious what you think!

I don't think I could've created that image a few weeks ago.

Just wondering has anyone done this for their dashboard, hoping to get an 8 inch tablet that I can get a white case and glue some flat pegs to it to make it somewhat flush. Any recommendations for an 8inch tablet with battery management built in?

We built an agent on top of our Zendesk queue. It triages incoming tickets, pulls context from our internal knowledge base, and drafts responses for the support team to review. Logging looked complete, each run had a record.

Then we found a case where it pulled customer data and used an external tool during a workflow. Because of a misconfiguration, data went to the wrong place. Logs helped trace the steps but didn't show what was sent or returned. You can see a tool was called, not what went through it.

Found out when the damage was already done.

how are you getting visibility into what data an agent actually used, not just which tools it ran

My notes live in Obsidian. My reading and highlights live in Readwise. My topical research lives in NotebookLM.

Each tool is great on its own. However, no AI I tried could reach across all three. Every time I reached for Perplexity or Gemini Deep Research, the output read like everyone else's.

I built a deep research agent as three Claude Code skills sitting on top of three command-line interfaces (CLIs). The skills are /research_create, /research_search, and /research_distill. They sit over obsidian, readwise, and nlm.

I use no vector database. I use no Retrieval-Augmented Generation (RAG) pipeline. I use no embeddings. Similar to Karpathy's LLM Knowledge base proposal, but using my whole second brain as raw files, creating targeted wiki's per project.

I just use Markdown, YAML, and JSON on my disk. The output of a research run is a memory/ folder for one topic. I throw it away when I am done.

The system relies on multi-round query expansion. Round one creates several queries from the seed and runs a researcher subagent per query in parallel. It then aggregates the results, runs a gap analysis, and fires off round two.

Here are some design decisions:

1. Use the filesystem as your state, not a vector database. The raw files stay immutable while the create skill emits an ephemeral memory folder with an index file and the source files.

2. Make index.yaml your progressive-disclosure wiki. You create one entry per source with the full file path, highlights path, original path, title, authors, date, publication, summary, tags, and a relevance score. The agent reads the index first, picks three to five relevant files from the summaries, and reads only those files. This creates three layers of detail: the summary in the index which is always loaded, an optional key-highlights file containing manual highlights for a huge signal, and the full document as a last resort. Because this is a YAML file the agent can easily write code to search, filter and sort items.

3. Keep the orchestrator context-free. The orchestrator schedules researcher subagents in parallel, and each subagent reads its slice, deduplicates the findings, and returns a compressed JSON summary. Subagents compress tens of thousands of input tokens into 1,000 to 2,000 output tokens, so the orchestrator only ever sees structured metadata instead of raw content. The actual file gets moved into the memory folder with a bash mv command, not by passing bytes through the model.

The thing that surprised me was how small the index stays. Even at 100 to 200 sources, the index stays around 700 to 1,000 lines.

The thing that would have killed this project was letting the orchestrator load source files directly. I do not want to parse 200 files individually. That blows your context budget and your Claude Code $200 subscription in one query.

I also learned a hard lesson about Obsidian. Letting the LLM roam the Obsidian vault directly is around 10x more expensive than using the Obsidian CLI local index.

What do you use for your private deep research layer? Are you building memory-folder style systems on top of your own notes? Or are you still pointing a vector database at everything and hoping it works?

TL;DR: For personal-scale private research, a memory folder with an index file and progressive disclosure beats a RAG pipeline on cost, traceability, and correctness. Keep your orchestrator context-free, let subagents touch the raw files, and use command-line tools whenever possible, even for Obsidian.

after months of building i finally hit launch. GetItSigned is a pay-per-use esignature tool: upload pdf, drop signature fields, send a link. signer signs on any device, no account required. you get a signed pdf + audit trail. credits never expire, only charged when the doc is fully signed. no subscription, no seat fees, down to $0.50/envelope on the 50-pack.

would really appreciate your feedback and an upvote if you like it: https://www.producthunt.com/products/getitsigned?launch=getitsigned

The more I learn about prompting, saving tokens, etc the more i get bogged down and confused in my process. If I am using Claude Code to build a pretty standard agent, am I over thinking it by planning and building prompts with Claude AI? Am I better off utilizing Claude Code for everything? I am struggling to understand when a certain tool makes the most sense for what tasks. I am sure there is more "information" available on this, but my head hurts trying to make sense of it.

Damn, this new image gen really is crazy

Occasionally without promt, primarily on sonnet 4.6 it gives answers in an internal-look json. Pretty cool imo

The title is the prompt

Currently using opencode cli with lm studio, qwen 3.6 35b a3b q4, running on mac 5pro 64gb, at 55-70tps, ram uses about 35gb

With this setup and codex reviewing the work by qwen, qwen is achieving about 90% of completion quality, tend to overlook one or two things.

Anyone got tips on how to better improve the code quality or am I doing something wrong, or if I should try to use the new qwen 3.6 27b instead?

I have a 20x Claude account and have been using Opus 4.7 exclusively for all code. I noticed even after asking multiple times to do code review, Opus would still not get there 100%.

Here is what I did:

1. Installed Codex cli and ran it in a Tmux session
   
2. Claude created PR for Codex to review
   
3. Claude pinged Codex via shell so I can see the Codex thinking and approve any file permission. Claude set a wake up window.
   
4. Codex reviewed and updated comments in PR.
   
5. Claude woke up and validated the comments before editing code.

Surprisingly Claude missed a lot of things and it was worth having Codex do the review.

I've been running on and off for years and my biggest problem was never motivation — it was that I'd miss two sessions and the whole plan would fall apart. So I built something to fix that.

RunAdapt is a training plan that adjusts itself when you miss a session. Skip one? It reschedules. Miss two in a row? It lowers the intensity. Too far behind? It moves your race date instead of pretending you're still on track.

Takes ~2 minutes to set up (goal, level, available days). No credit card.

runadapt.vercel.app

Looking for honest feedback — what's missing, what's confusing, what would actually make you use it. Be brutal.

https://preview.redd.it/tmd2bmf603xg1.png?width=960&format=png&auto=webp&s=571783affd4d2d2fc39b637f26e7f98f708f53f6

I am very interested in the amount of people who are convinced AI is sentient. I was curious about what Claude had to say about it.

https://preview.redd.it/ythkw27j03xg1.png?width=776&format=png&auto=webp&s=d10e5ebb8cd089b91a0ece2de45186929de67bdd

Please be careful when interacting with these things. We have no idea of the damage they could be doing, and I highly doubt any one of these companies are going to openly share this data up front - until we hear about them in lawsuits. Even then, we will likely only get the tip of the iceberg.

I have tried to tell it not to do this but as you can see it is making the images unusable , anyone having the same issue?

https://preview.redd.it/pnzoh50jb3xg1.png?width=1677&format=png&auto=webp&s=e31059dacfe7946b9a5b9f5d97d74d16d4b549c7

https://preview.redd.it/8uo27nunb3xg1.png?width=1684&format=png&auto=webp&s=9ea7e7ec4774b04fe124abe1de1b057b53a97667

https://preview.redd.it/pb5jwitpb3xg1.png?width=1681&format=png&auto=webp&s=edb7e17b76b8247d7a2de3f7e8f678788efc4111