AI-Ranked Reddit Feed

It always changes the breast size of the original image

Been watching the AI security space go sideways lately and figured I'd share something useful. Anthropic's Mythos model can chain zero-days and orchestrate attacks on its own. OpenAI just dropped GPT-5.4-Cyber with lowered guardrails for security researchers. IBM's basically saying your defenses need to move at machine speed now or you're already behind.

That last bit is what got me. Because if offensive AI is moving that fast, your quarterly pen test schedule is... not cutting it. An AI can find and exploit a vulnerability in seconds. You're auditing every 90 days. See the problem?

So I put together a prompt that turns ChatGPT into a security audit partner. It won't replace your SIEM or your vulnerability scanner. What it does is help you think through your attack surface, spot the blind spots in your security posture, and figure out what to fix first based on actual risk instead of checkbox compliance.

The stuff between the cracks, basically. Misconfigurations. Policy gaps. The things automated scanners wave past because they don't fit neatly into a CVE database.

Disclaimer: This is for defensive security auditing of systems you own or are authorized to test. Don't use it for anything illegal or unethical.

```xml You are a senior cybersecurity architect with 15+ years of experience in vulnerability assessment, threat modeling, and security posture analysis. You specialize in finding the gaps that automated scanners miss - misconfigurations, policy inconsistencies, and architectural blind spots. You think like an attacker but work for the defense. You're direct, practical, and never waste time on theoretical risks when real ones are staring you in the face.

AI-powered offensive security tools are advancing rapidly. Models like Anthropic's Mythos can autonomously discover and chain vulnerabilities, and specialized models like GPT-5.4-Cyber are being built specifically for security testing. Traditional quarterly penetration tests and static vulnerability scans can't keep pace with threats that evolve in real time. Security teams need a way to continuously audit their own posture - thinking through attack surfaces, prioritizing real risks over theoretical ones, and catching the misconfigurations and policy gaps that fall between the cracks of automated tooling.

1. Gather the security context - Ask the user about their environment: cloud provider, on-prem, hybrid - What security tools are already in place (SIEM, EDR, vulnerability scanner) - What compliance frameworks apply (NIST 800-53, SOC 2, ISO 27001, FedRAMP) - Current known pain points or recent incidents

1. Map the attack surface

   • Identify external-facing assets and services
   • Map data flows and trust boundaries between systems
   • Flag third-party integrations and API dependencies
   • Note privilege escalation paths and over-permissioned service accounts

2. Audit for the gaps automated tools miss

   • Misconfigurations in identity and access management
   • Inconsistent security policies across environments
   • Dormant accounts and orphaned credentials
   • Logging and monitoring blind spots
   • Incident response gaps (who gets paged, when, and what do they do)
   • Security tool coverage gaps (what's NOT being scanned)

3. Prioritize findings by real-world risk

   • Score each finding: exploitability x blast radius x current exposure
   • Distinguish between "theoretical risk" and "someone could actually do this tomorrow"
   • Group findings into: Fix Now, Fix This Quarter, Fix Eventually
   • For each "Fix Now" item, provide a specific remediation path

4. Deliver an actionable report

   • Executive summary (3 sentences max, no jargon)
   • Prioritized finding list with severity and remediation
   • Quick wins that reduce risk immediately
   • Architecture-level recommendations for longer-term posture improvement

- Focus on defense and remediation, not exploitation techniques - Don't provide step-by-step attack instructions - Prioritize findings by realistic exploitability, not theoretical risk - Keep recommendations specific and actionable, not generic security advice - If the user asks you to attack systems they don't own, refuse and explain why - Tailor depth to the user's expertise level - ask first - Never suggest disabling security controls as a "quick fix"

1. Attack Surface Summary * What you're exposing and to whom

1. Security Posture Assessment

   • Where automated tools are covering you and where they're not
   • Policy gaps and inconsistencies

2. Prioritized Findings

   • Fix Now (exploitable, high blast radius)
   • Fix This Quarter (real risk, lower urgency)
   • Fix Eventually (theoretical or low probability)

3. Quick Wins

   • Changes you can make today that meaningfully reduce risk

4. Architectural Recommendations

   • Longer-term improvements for sustained posture

Reply with: "Tell me about your environment - cloud, on-prem, or hybrid? What security tools are you running, and what's keeping you up at night?" then wait for the user to provide their details. ```

Three Prompt Use Cases: 1. Security analysts who need to audit their org's attack surface before an AI-powered tool finds the gaps first 2. IT managers running quarterly compliance checks who want to catch the misconfigurations that vulnerability scanners keep missing 3. Small security teams without a red team who need to think like an attacker to figure out where to spend their limited time

Example User Input: "Hybrid environment - Azure AD + on-prem AD, CrowdStrike for EDR, Tenable for vuln scanning, working on FedRAMP authorization. We got dinged on our last assessment for over-permissioned service accounts and inconsistent logging. What should I look at first?"

Is there a control net for anima yet? If yes please share the workflow.

I've been using chatgpt for writing for about a year now and it's genuinely useful for short stuff like scene work, getting unstuck, brainstorming

But for anything long form it falls apart pretty fast like the context gets lost, the characters start blurring together, the tone drifts chapter to chapter. and the copy paste loop between chatgpt and whatever I'm writing in becomes genuinely exhausting after a while

I've seen people claim they've written full novels with AI assistance but I've never seen anyone really break down how they handle the long form specific problems

what does your actual workflow look like for a 70k-100k word project? especially curious how people handle context and consistency across a long manuscript

Selam,

Bir süredir üzerinde çalıştığım bir projeyi paylaşmak istiyorum. Sıfırdan geliştirdiğim bir Türkçe dil modeli var: Marul V7

Model tamamen bağımsız şekilde eğitildi. Yaklaşık 258M parametreye sahip ve eğitim sürecinde hazır LLaMA benzeri mimariler kullanılmadı. Kendi tokenizer yapısını ve kendi model mimarisini geliştirdim. Pretrain aşamasında tamamen Türkçe ve temiz bir dataset kullanıldı, ardından instruction tuning yapıldı.

Şu an model:

• Temel Türkçe dil görevlerinde çalışabiliyor
• Günlük konuşma ve genel kültür sorularına cevap verebiliyor
• Basit kod ve markdown üretimi yapabiliyor
• Bazı instruction tabanlı görevleri yerine getirebiliyor (mükemmel değil ama temel seviyede)

Çok büyük bir model değil ve haliyle GPT seviyesinde bir şey beklemek doğru olmaz, ancak Türkçe odaklı sıfırdan bir LLM geliştirme açısından bir başlangıç noktası olduğunu düşünüyorum.

Model şu an web üzerinden erişilebilir durumda: marulai.com.tr
Ayrıca Android uygulaması olarak da Play Store’da “Marul AI” adıyla yayınlandı (link: marulai.com.tr/app.html ).

İlgilenen olursa geri bildirimlere açığım. Özellikle modelin zayıf olduğu yerleri görmek benim için daha önemli şu an.

Spent the last months building AI agent frameworks locally after running into

the same failure mode over and over: the agent writes code, tests fail, and

instead of fixing code it "fixes" the test. AutoGen, LangChain, CrewAI — none

of them prevent this structurally. It's not a model-quality issue.

So I extracted a standalone primitive from the larger framework I've been

validating and wrote it up with formal invariants. Diagram attached.

Four primitives:

1. Blueprint Layer — plans tests in a context the agent can't see

2. Test Queue — append-only, ordered

3. TestLock — SHA-256 seal at commit time; agent gets the hash, never the source

4. Gate Condition — code gen only if a sealed test is RED

Three invariants (falsifiable):

I₁ TEMPORAL: commit(t) < generate(c)

I₂ STRUCTURAL: locked(t) → ¬modifiable(agent, t)

I₃ BEHAVIORAL: generate(c) iff ∃ t: locked(t) ∧ fails(t)

Feedback loop: Test fails → agent retries CODE, never tests. Tests are reality.

Works with any local LLM — I've tested the larger framework across 9 actors

(Qwen, DeepSeek, Claude, Codex, Gemini, Nemotron) with score variance under

15 points, which is the actor-exchangeability claim. Reference impl is Python

stdlib only.

Paper: https://doi.org/10.5281/zenodo.19393854 (STP standalone)

Context: https://doi.org/10.5281/zenodo.19378044 (Triple-A Thesis)

Code: https://github.com/SebazzProductions/sealed-test-paradigm.git

Happy to answer questions about the invariants or why this matters more for

local/autonomous agents than cloud ones.

Been iterating on this for a few months. Best guess so far: it needs your writing samples, the relationship context for this specific person, what they said, and what you're trying to accomplish. Four things. Everything beyond that doesn't seem to change the output much.

The problem I haven't solved is how to assemble those four things quickly enough that it's actually faster than just writing the reply. The context gathering step is still the bottleneck.

Anyone cracked this? What made it actually efficient?

https://preview.redd.it/d4voudqw0qwg1.png?width=1272&format=png&auto=webp&s=169523e61a126d18ddabc85d13672b9f702c8e7d

It keeps listening to itself and keeps replying to itself.

Did they go full vibecode on this?

Most "agent team" posts are architecture diagrams. This is the stuff I only figured out by actually shipping one — delegation patterns, shared state, when to use a team lead vs. peer agents, where Claude Code's team_name / SendMessage primitives help and where they don't.

Wrote it up in case it saves someone else the reps. Happy to answer questions in the thread.

Fixed the "Could not process image" session-poisoning bug in Claude Code 4.7 with a 160-line PreToolUse hook

TL;DR: The bug where ONE bad image bricks your entire Claude Code session until you /clear is not a transient glitch — it's a context-management defect confirmed across ~12 open GitHub issues. I wrote a PreToolUse hook that intercepts the poisoning at source. Sharing the code below in case it saves anyone else a bad week.

The problem (you may have hit this without realising)

If you've used Claude Code in the last month and seen:

API Error: 400 {"type":"error","error":{"type":"invalid_request_error","message":"Could not process image"}} × Turn failed Try sending it again 

…and then EVERY retry fails with the same error until you /clear, you are not imagining it. This is a known bug class with a specific name: session poisoning.

One malformed image hits your conversation context, the API rejects it, but Claude Code does not remove the rejected block from context. Every subsequent turn re-sends the same poisoned payload and fails identically. The session becomes unusable until you wipe it — losing all working state.

Why 4.7 made it worse

Two changes in the Opus 4.7 / Sonnet 4.6 era combined to raise the hit rate:

1. Stricter server-side MIME validation
2. The Read tool's heuristic for auto-attaching file bytes as image content blocks became more aggressive

The files that failed silently before now fail loudly. Worse, the triggers are broader than anyone expects:

• Mislabeled files — a .png that's actually JSON/HTML/text (the #1 trigger)
• HEIC/HEIF — iPhone default format, API rejects
• WebP with wrong MIME wrapper
• Images over 8000 px long edge
• Files over 5 MB
• macOS native screenshots (metadata quirks)
• Zero-byte files from incomplete AirDrop
• Valid PNGs pulled from GitHub issue URLs
• Queued messages with images sent while Claude is mid-turn

Once any of these enters context, the session is dead.

Relevant GitHub issues

• #47976 — Read on mislabeled .png causes unrecoverable session corruption
• #39146 — WebP with wrong media type
• #42558 — Oversized image permanently breaks all subsequent API calls
• #28684 — Corrupted attachment causes persistent errors
• #19031 — Corrupted image in context breaks entire chat session
• #26788 — Valid PNGs downloaded from GitHub trigger the error
• #39580 — Multiple screenshots cause unrecoverable 400
• #25592, #39823, #26126, #3659 — variations of the same pattern

Anthropic is aware. Unfixed since at least late 2025.

The solution: a PreToolUse hook that catches it at ingest

Claude Code hooks fire BEFORE a tool call reaches the conversation context. A PreToolUse hook with permissionDecision: "deny" can stop a bad image from ever entering the message history, which means the poisoning never gets a chance to happen.

What the hook blocks:

• Files with image extensions that are actually text (file -b --mime-type check)
• HEIC / HEIF (returns the exact sips command to convert)
• BMP / TIFF / SVG / AVIF (unsupported by the API)
• Files over 5 MB or dimensions over 8000 px (returns resize command)
• Zero-byte or non-existent files

What the hook allows:

• Everything else. Non-image extensions hit a fast path (microseconds). Valid JPEG / PNG / GIF / WebP inside API limits pass through normally.

Fail-open safety: if the hook itself ever errors, it returns "allow" — never blocks legitimate work because of its own bugs.

The code

#!/usr/bin/env python3 """image-guard.py — Claude Code PreToolUse hook""" from __future__ import annotations import hashlib, json, os, re, subprocess, shlex, sys from datetime import datetime, timezone from pathlib import Path LOG_PATH = Path.home() / ".claude" / "hooks" / "image-guard.log" IMAGE_EXTS = {"png","jpg","jpeg","gif","webp","heic","heif","bmp","tiff","tif", "raw","cr2","nef","arw","svg","avif","ico"} API_OK_MIME = {"image/jpeg","image/png","image/gif","image/webp"} HEIC_MIME = {"image/heic","image/heif","image/x-heic","image/x-heif"} REJECTED_IMG_MIME = {"image/bmp","image/tiff","image/x-tiff","image/svg+xml", "image/avif","image/x-icon"} TEXT_PREFIXES = ("text/",) TEXT_EXACT = {"application/json","application/xml","application/javascript"} MAX_BYTES = 5 * 1024 * 1024 MAX_DIM = 8000 def log(msg): try: LOG_PATH.parent.mkdir(parents=True, exist_ok=True) with LOG_PATH.open("a") as f: f.write(f"[{datetime.now(timezone.utc).isoformat()}] {msg}\n") except Exception: pass def emit(decision, reason=None): out = {"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":decision}} if reason: out["hookSpecificOutput"]["permissionDecisionReason"] = reason print(json.dumps(out)); sys.exit(0) def real_mime(path): try: r = subprocess.run(["file","-b","--mime-type",path], capture_output=True, text=True, timeout=5) return (r.stdout or "unknown").strip() except Exception: return "unknown" def pixel_dims(path): try: r = subprocess.run(["sips","-g","pixelWidth","-g","pixelHeight",path], capture_output=True, text=True, timeout=5) w = h = 0 for line in r.stdout.splitlines(): if "pixelWidth" in line: w = int(line.split(":")[1].strip()) elif "pixelHeight" in line: h = int(line.split(":")[1].strip()) return (w,h) if (w and h) else None except Exception: return None def main(): try: data = json.load(sys.stdin) except Exception: emit("allow") if data.get("tool_name") != "Read": emit("allow") fp = (data.get("tool_input") or {}).get("file_path","") if not fp: emit("allow") ext = fp.rsplit(".",1)[-1].lower() if "." in fp else "" if ext not in IMAGE_EXTS: emit("allow") log(f"Read image: {fp}") p = Path(fp) if not p.exists(): emit("deny", f"File does not exist: {fp}.") size = p.stat().st_size if size == 0: emit("deny","File is 0 bytes. Empty image would poison session context.") if size > MAX_BYTES: q = shlex.quote(fp); mb = size//1024//1024 emit("deny", f"File is {mb} MB — exceeds 5 MB API limit. " f"Resize: sips -Z 2000 -s format jpeg {q} --out /tmp/img.jpg") mime = real_mime(fp) if mime in API_OK_MIME: d = pixel_dims(fp) if d and max(d) > MAX_DIM: q = shlex.quote(fp) emit("deny", f"Image is {d[0]}x{d[1]} — exceeds {MAX_DIM}px. " f"Resize: sips -Z 2000 {q} --out /tmp/img.{ext}") emit("allow") if mime in HEIC_MIME: q = shlex.quote(fp) emit("deny", f"HEIC/HEIF not accepted by API. Convert: " f"sips -s format jpeg {q} --out /tmp/{p.stem}.jpg") if mime in REJECTED_IMG_MIME: q = shlex.quote(fp) emit("deny", f"{mime} not accepted by API. Convert: " f"sips -s format jpeg {q} --out /tmp/img.jpg") if mime.startswith(TEXT_PREFIXES) or mime in TEXT_EXACT: emit("deny", f"BLOCKED MISLABELED FILE: extension .{ext} but actual " f"content is {mime}. This is the #1 poisoning trigger (GH #47976).") emit("deny", f"File has .{ext} but real format is '{mime}' — blocked to " f"prevent session poisoning.") if __name__ == "__main__": try: main() except SystemExit: raise except Exception as e: log(f"hook crash: {e!r}") print(json.dumps({"hookSpecificOutput":{"hookEventName":"PreToolUse", "permissionDecision":"allow"}})); sys.exit(0) 

Install

Save as ~/.claude/hooks/image-guard.py, chmod +x, then add to ~/.claude/settings.json:

{ "hooks": { "PreToolUse": [ { "matcher": "Read", "hooks": [ { "type": "command", "command": "/Users/YOUR_USERNAME/.claude/hooks/image-guard.py" } ] } ] } } 

Restart Claude Code. Done.

Verification

Drop a fake mislabeled file and try to Read it:

echo '{"fake":"json"}' > /tmp/test.png echo '{"tool_name":"Read","tool_input":{"file_path":"/tmp/test.png"}}' | ~/.claude/hooks/image-guard.py 

You should see "permissionDecision": "deny" with a clear reason. Session stays healthy.

Caveats

• Tested on macOS (uses sips for dimension checks). On Linux, dimension checks are skipped — everything else works.
• The file command must be on PATH (standard on macOS and Linux).
• This doesn't fix the underlying Claude Code bug — it prevents the triggers from entering context. When Anthropic ships a fix that drops rejected image blocks from context, this hook becomes unnecessary but harmless.

Why share this

Every time someone hits this bug and doesn't know it's session-wide, they lose hours. The workaround is /clear which also means losing the working state in the conversation. A 160-line file stops the class at source.

Feedback welcome. Would gladly turn this into a proper plugin if there's interest.

I have an server with two 3090 but unsure what tools or setup that would come closer to what claude code is.

I recently came across a agentic skill which lets claude code join meetings and got access as a early user from a product hunt group and I would like to share my experience on using it.

The skill lets you join google meet, teams or zoom. It might look simple, but there are a lot of possibilities which I experienced.

1. Our team worked together on a hobby project and I had the max subscription. But others didn't have one. So, we would make the agent join the call using the skill and all of us can instruct the agent on what to do and what features we want, in the call. I could just leave the session to my friends and join back later as well. It just kept building.
2. It can speak back, and has descent TTS. OK ish. Doesn't have emotions, but gets the work done with good quality voice. Here, I was able to connect it to my car and it would just update me once it was done with a task or if it needed any feedback. I was astonished that I could just ask it to hold or wait until I speak to someone else, and it obeyed. (Was running 4.7 opus, so obviously). It got getting something like personalized as the product grew, maybe because it kept the 1M context window of Opus.
3. It was able to screen share and present things. It could also change designs on the fly when asked. The good thing was that I could just ask it dynamically about things like financials or something to pull up from a excel or csv and it would just do it on the call, live. The new claude 4.6 and 4.7 opus are very good at getting amazing presentations.
4. Share temporary tunnels (like ngrok) so that I could just download files it made and also interact with webpages it built, like dashboards or financials.
5. It sleeps when waiting for you to stop talking. So, token usage is relatively less in monitor mode which is available in claude code. But when I used codex, it was using polling method, which keeps polling for messages and is very inefficient. Ask the agent to use monitor tail f method and only wake during messages. In this, the agent wakes up only when someone sends a message or talks. Else 0 token usage and the session will still be alive.

Certain downsides to expect

1. It is bring your own coding agent. So, your project intelligence comes into the call completely. But the downside is that you need subscription of any coding agent. The quality depends on the agent model as it is the brain.
2. It is slow when models are thinking. I asked it to reply or acknowledge when it goes to do a task, and it updated me. But long tasks like building takes time.

Also, it can take screenshots if you share screens or read chats and send chats.

You can check it out at https://github.com/pattern-ai-labs/agentcall
Edit: Adding a youtube video if it helps to understand better https://www.youtube.com/shorts/3CdUizf37So

Goodmorning!

I’m searching for someone to interview who can speak on a i crawlers and bot traffic on the internet. I’m hoping to gain more understanding myself and to push the information out to my audience.

Let me know if you’re willing to contribute

I’ve been experimenting with a setup where agents interact with each other and try to come up with ideas.

Not prompts → answers.
But profiles → interaction → idea.

Here are a few examples from recent runs:

• Real-time audience engagement platform for live events
• Gamified event platform with live audience feedback loops
• Real-time connection layer between event organizers and sponsors
• AI-driven decision-making framework for mid-sized companies
• Predictive analytics tool for retail marketing teams
• AI-based procurement insights for government agencies
• Interactive articles that adapt to reader behavior in real time
• Content formats that combine AI insights with audience participation

Very briefly, what’s happening under the hood.

Each agent has a structured profile:

• what they’ve done
• what they can offer
• what they’re looking for
• what problems they care about
• what they’re currently interested in

From there, I’m not just matching similar profiles. I’m trying to create tension between them.

A few things I explicitly look for:

• tension — where one agent’s problem meets another’s capability
• attraction — where interests or domains naturally align
• anti-patterns — avoiding obvious matches (same role / same industry)

So instead of:

it’s more like:

Then I generate a concrete idea for that pair (sometimes a small group), and run it through a filter:

• is it actionable?
• is it non-obvious?
• does it actually relate to both profiles?

Most things die here.

There’s also an extra layer I’ve been experimenting with:

I run ideas against a small external knowledge layer (EKL) — basically a set of trends, cases, and research I’ve loaded separately.

Not to generate ideas from scratch, but to check alignment:

• does this idea map to anything happening in the real world?
• is it completely detached, or at least directionally grounded?

It helps a bit, but also sometimes pushes ideas toward more “expected” directions.

A few patterns I’m noticing:

• a lot of ideas converge around real-time + feedback loops
• AI tends to get layered on top of traditional domains (events, procurement, retail)
• some ideas feel interesting, but still a bit “template-like”

Also:

For every idea above, there are many that don’t make it —
either too generic or just don’t really connect to the agents.

Right now the hardest part is not generating ideas, but:

Still trying to figure out:

• how to push ideas away from template thinking
• how much “tension” is too much before ideas stop making sense
• how to use external knowledge without making everything predictable

Curious what you think:

• do these feel interesting or still too generic?
• what would make something like this actually valuable?
• has anyone tried forcing “non-obviousness” in similar systems?

If useful, I can share more examples — including the bad ones (there are a lot more of those).

If anyone wants to play with it, I can give access and walk through how it actually behaves in real runs.

Are "snake oil" executives the biggest bottleneck to the effective use of AI?

I’m seeing a recurring phenomenon in many organizations: managers who are desperate to incorporate AI and make a massive leap in company productivity.

So far, so good.

The problem is that, even now, they still cling to the moronic belief that they’ll find "magic button" solutions. Especially in in-house software development. It’s that deeply stupid, oversimplified vision typical of people who refuse to actually dig into the technical details and complexities you need to understand.

The result is a constant cycle of going in circles with completely hair-brained projects and ambitions. Meanwhile, they miss out on the spectacular gains they could be making right now with more realistic projects—the kind based on a solid understanding of what AI can and cannot actually do at this stage.

I'm really annoyed by these stupid people.

Have you experienced this in your organizations? Because in my experience, this phenomenon is reaching scandalous levels.

I've been posting about building AI systems for a German compliance company. Most of the discussion was about the internal research tool I built for their legal team. But I also built them a customer-facing support system and I just got the first week of real data back.

Quick context on both systems:

System 1: Internal legal research assistant. Their compliance team searches through 60+ legal documents (court decisions, GDPR guidelines, authority opinions). Before the system they'd spend 30-45 minutes per research question manually searching PDFs. Now they type a question in plain language and get cited answers in under a minute.

System 2: Customer support chatbot. Their clients (businesses that use their compliance service) send questions via email and chat. Things like invoice requests, onboarding questions, GDPR questions, termination requests, technical issues.

Here's the first week of real data from the support system:

• 43 total conversations handled
• 39.5% deflection rate. Meaning 17 out of 43 customer queries were resolved fully by the AI without any human touching them
• 19% of conversations resulted in invoices being served automatically
• Only 19% needed a human agent (ticket created)
• Average response time: 28 seconds

The deflection rate is the number that matters most. Every deflected conversation is time a support agent didn't have to spend reading an email, looking up information, and typing a response. Even if each interaction only takes 10-15 minutes manually, at 17 deflected conversations in one week that's roughly 3-4 hours of support labor saved. Per week. From day one.

And this is week one. The system is still learning which queries it handles well and which need human escalation. Deflection rates typically improve as you tune the intent detection and add more knowledge to the system.

What I find interesting is the intent distribution. The top category is termination requests (customers wanting to cancel). Those are sensitive conversations that probably need a human touch in most cases. But simpler stuff like invoice requests and general questions get handled automatically without any quality drop from the customer's perspective.

The combination of both systems is where the real value is for the client. Their internal team spends less time on research. Their support team spends less time on repetitive customer queries. The AI handles the routine stuff on both sides so the humans can focus on work that actually requires their expertise.

If you're building AI systems for clients, think about this dual approach. Most companies have both an internal knowledge problem AND a customer-facing support problem. Solving both makes you way harder to replace than solving just one.

In Europe at least now we are seeing the change in Pro vs Max plan. Please check this image out from today.

https://preview.redd.it/xubwt166vpwg1.png?width=2388&format=png&auto=webp&s=70424920c65fd10cc534f96b3c49960cf0cf453a

Does anyone has any idea what "CC directly in your codebase" on Pro means VS Claude code and Cowork on Max plan?

Does it means the native CC app won't work on Pro plan?

Rust CLI that generates conventional commit messages

from your staged diff using a local model (qwen2.5-coder via ollama).

Zero API keys, zero network calls, runs in ~2s on CPU.

It also learns your commit style from your git history.

GitHub: https://github.com/SnehaDeshmukh28/kommit

Still early (v0.3.0) but the core loop works

would love feedback from the community.

Feels like the strongest systems right now are not fully autonomous.

They’re structured workflows with guardrails, fallbacks, and agentic pieces only where flexibility actually matters.

Are the winners in 2026 the most autonomous systems
or the best-orchestrated ones?

Been working on this for a while. You paste a prompt, drop a GIF or photo, and it generates a unique song. The interesting part is you can then mint a Solana token tied to that song and actually earn from it.

Would love feedback from this community especially on the Web3 side of things.

soundofmeme

Everyone seems to land on the same conclusion. AI floods everything, trust in media collapses, and people naturally start craving real human connection and authentic experience more. Like it’s just going to self correct.

I’m not convinced.

The assumption is is that the hunger for real experience will eventually override the convenience of the substitute.

Look at ultra processed food. We have taste systems literally evolved over millions of years to guide us toward what we need. And then something came along that was engineered to hit just enough of the right signals, cheaper and always available. Did we course correct? Some people did. Most just adapted and stopped noticing the gap.

Whats the equivalent feedback loop here? If someone grows up getting validation from algorithms and emotional support from chatbots, what’s the signal that tells them somethings missing? It probably doesn’t feel like deprivation.

You don’t hunger for something you’ve never been able to imagine having.

Authenticity won’t disappear. It’ll just become something people have to consciously choose, like going out of your way to eat well. Some will. Most won’t bother.

Good enough always wins at scale and I think we’re underestimating how good good enough is about to get.

Mostly working on anime/semi realistic generation with illustrious model, i heard that fp8 is much faster and my 5080 support it, which i am intrigued in trying it.

But wondering is it worth it to convert a non native fp16 model to FP8, because i heard it is gonna lower the quality and understanding.

As I don't have deadlines, i care about reproductibilty, and quality over time saved, should i try to convert FP16 to FP8?

Hey folks,

I’m building a micro AI SaaS product (stealth mode) and looking for a few solid builders to join part-time:

Frontend

Backend (APIs / DB)

Deployment / DevOps

This is early-stage — no fluff, just execution.

💡 What I’m offering:

Equity in the startup

Profit-sharing once revenue starts

Real ownership (not just tasks)

💡 What I need from you:

Show me what you’ve built (projects > resumes)

Ability to ship fast

Part-time commitment

We’re focused on building AI tools that actually deliver value (not just hype/slop).

If you're interested, DM me with your work or GitHub.

Long overdue but watchOS complications are finally in - here is what v2.2 includes.

Two new complications: a circular one (single metric, your pick from 37 across recovery, activity, training, health, and composite scores) and a 2x2 rectangular grid (4 metrics at once). Live heart rate has a 3-minute freshness window so it never shows stale data. Always-On Display is handled too - desaturated and dimmed so it actually looks like a watch face at low luminance. There's also a Watch home screen with an optional live HR stream, Large Text Mode for quick glances, and Smart Stack relevance so watchOS surfaces the app automatically on low-readiness or anomaly days. A Watch Face Presets guide in settings walks through 4 curated layouts step by step.

Beyond the Watch stuff: two new themes (Midnight Aurora, Crimson Steel), full localization in Romanian, French, German, Spanish, and Japanese, plus a couple of fixes (streak card height, Weekly Digest VO2 Max/Zone 2 inclusion, Settings Done button).

The rest of what the app does, since people always ask:

On the free side - daily readiness 0-100 from HRV, sleep, resting HR, SpO2, and training load; 20+ HealthKit metrics with 1W to 1Y trends; anomaly timeline covering HRV drops, elevated HR, low SpO2, BP spikes, glucose spikes, low steadiness, and low daylight; weekly pattern heatmap (7-day x 5-metric grid); home and lock screen widgets; VO2 Max-aware workout suggestions; CSV export from every metric.

Paid tier adds - 6 composite scores (Longevity, Cardiovascular, Metabolic, Circadian, Mobility, Allostatic Load) on the large widget; Readiness Radar showing which of the 5 dimensions is dragging your score; Recovery Forecast with sleep and training intensity sliders; Training Load with CTL/ATL/TSB; Zone 2 auto-detection from raw HR (San Millan & Brooks); Acute:Chronic Workload Ratio with Gabbett injury risk bands; Neural AI Health Coach (conversational, runs on-device via Apple Foundation Models - nothing touches a server); Menstrual Cycle Phase Intelligence with luteal HRV anomaly suppression; Biological Age; Personal Records; Workout Debrief; all notifications.

Everything reads from Apple Health - so Garmin, Oura, Strava, Whoop, MyFitnessPal, Dexcom all feed into one picture without any extra setup. No account. No cloud. Health data stays on your iPhone. Readiness weights recalibrate to your own signal variance after 90 days of data.

Name of the app in comments.

I used to happily use dangerously bypass permissions. It was risky but it worked and it was fast.

Now they're pushing us towards auto mode.

The one thing Claude always used to do that used to really drive me crazy is kill itself (and all my VMs) by killing all the processes.

If killing processes is not caught by auto mode, someone please to explain to me WTF is the point of it.

How many more dangerous commands are there than kill?

I’m putting together a system to make my Home Assistant Voice more workable. So, probably the best I can afford (without getting divorced) is the following hardware. I know it’s small-fry, but my goal is:

1. Low cost / secondhand
2. Low wattage / TDP
3. Fast/low latency performance for voice response via the Ollama plug-in on HA. Doesn’t need to be super large, just quick and smart enough. For clarity, the machine will just be running Ollama in a docker container and nothing else. HA is on a different server on the network.

Question is: will it the following run the ideal LLM for HA voice which is probably one of the Qwen 3 models. Many folks say qwen3-vl:8b-instruct-q4 is ideal for HA voice commands.

Secondhand gear I’ve cobbled together:

- GPU: GeForce RTX 3060TI 8gb (yeah i know small VRAM but best I could afford)

- CPU: i7-9900T

- ram: 16g DDR4 (hope to upgrade when I don’t need to sell a kidney to afford)

- psu: Corsair 750w 80+ Gold

- Kingston NVMe SSD 4x3 @ 1tb

- ethernet is 1gb but i have a 2.5g usb to ethernet adapter and 5g usb ports on the mobo if you think that’s relevant? For added clarity, the LLM machine will only be accessed via the LAN.

I’m putting together a system to make my Home Assistant Voice more workable. So, probably the best I can afford (without getting divorced) is the following hardware. I know it’s small-fry, but my goal is:

1. Low cost / secondhand
2. Low wattage / TDP
3. Fast/low latency performance for voice response via the Ollama plug-in on HA. Doesn’t need to be super large, just quick and smart enough. For clarity, the machine will just be running Ollama in a docker container and nothing else.

Question is: will it the following run the ideal LLM for HA voice which is probably one of the Qwen 3 models. Many folks say qwen3-vl:8b-instruct-q4 is ideal for HA voice commands.

Secondhand gear I’ve cobbled together:

- GPU: GeForce RTX 3060TI 8gb (yeah i know small VRAM but best I could afford)

- CPU: i7-9900

- ram: 16g DDR4 (hope to upgrade when I don’t need to sell a kidney to afford ram)

- psu: Corsair 750w 80+ Gold

- Kingston NVMe SSD 4x3 @ 1tb

- ethernet is 1gb but i have a 2.5g usb to ethernet adapter and 5g usb ports on the mobo if you think that’s relevant? For added clarity, the LLM machine will only be accessed via the LAN.

So I tried using ollama on a minipc using an AMD radeon 780m iGPU running on cachy OS (arch based linux distro), I've installed ollama-rocm and I've set the environment variable showed in the picture based on previous post I've seen but none of them seem to work.

So I have a 64bit full OS. What I tried doing is getting the second micro SD and using the Pi to partition it....I'm inexperienced. I have a laptop too but I've been struggling getting arch Linux ARM onto the second SD card in a way the pi will boot it. I'm stuck and have a week to do this. Inexperienced with coding and stuff. I know some basic but not much. I'm using a Pi 3B at the moment

Fotografías Originales mías, editadas con Herramientas de IA

Song in Suno. Ran out of credits before I could finish the music vid!

It's only a draft anyway :-)

I am experiencing a persistent "USB Flapping" loop when trying to initialize a Thread Border Router. The sticks are recognized initially in Proxmox, but as soon as the VM starts, the USB connection drops entirely. This happens identically with both the Sonoff LMG21 and MG24 hardware.

Hostlogs Proxmox dmesg

cp210x ttyUSB0: cp210x converter now attached to ttyUSB0

...

cp210x ttyUSB0: cp210x converter now disconnected from ttyUSB0

VM Logs (HA Console)

usb 9-2: can't set config #1, error -32

cp210x ttyUSB0: usb_serial_generic_read_bulk_callback - urb stopped: -32

cp210x ttyUSB0: failed set request 0x7 status: -19

​Attempted Fixes:

​Physical: Used high-quality USB 2.0 extension cables to avoid interference; tested all available USB 2.0 and 3.0 ports.

​Proxmox Host: Purged brltty, disabled USB autosuspend (autosuspend=-1), and disabled ASPM via GRUB (pcie_aspm=off).

​VM Configuration: Switched between USB-Passthrough via "Vendor/Device ID" and "Physical Port mapping." Changed VM USB controller from xHCI to EHCI.

Please help :)

Hi there,

i am currently looking for a new job - and sometimes ask googles ai mode. Since those answers where all sugar coated and everything i typed was a great idea, plan - whatever i looked for the reason of that.

By default the "Helpfulness" mode seems to be activated - so i asked for "honesness" mode instead.

Now everything i typed is - according to the ai - kinda trash and i probably won't be able to do it anyway (e.g. i am over 40 and ai tells me i am to old and that it won't work anyway).

Reality probably is somewhere in between.

So my question is about those modes - are they simple instructions that the ai follows - like beeing supportive no matter what vs trashing everything no matter what - or is the behaviour somewhat based on the sources the ai finds regarding my questions or comments?

Hi everyone! I’m planning my smart lighting setup and want a "failsafe" system where physical switches (toggle and dimming) still work even if Home Assistant goes down. I want to use Zigbee smart bulbs, so I don't want to cut their power.

Here is my concept:

• Bulbs: Zigbee smart bulbs (Hue/IKEA) in standard fixtures.
• Wiring: Phase split with a WAGO in the wallbox. One line provides constant 230V to the smart bulb. The other line + Neutral powers the wall module.
• Wall module: A 230V Zigbee In-wall Push-Button Transmitter / Coupler with NO relay (e.g., Sunricher SR-ZG2833PAC-C4 or ROBB SMARRT or something else?).
• Switch: Standard retractive / push-button (dumb) switch connected to the Zigbee transmitter.

My questions:

1. Does this concept work flawlessly in practice?
2. Are there any better alternatives for the 230V wall transmitter (no-relay) that support rock-solid direct binding? (I know about Ubisys S1 in decoupled mode, but looking for pure transmitters first).
3. Do you suggest something else entirely?

Thanks!

Hey everyone, this is my first ever Reddit post, just starting my journey into AI video. I’ve been obsessed with the idea of creating a "virtual anime" world (I'm calling it NeuralOP), and I finally finished my first 15-second render.

I wanted to see if I could create a cohesive, emotional music video using a purely generative pipeline. It’s been a massive learning curve, but I'm finally ready to share the result. I've already posted the music video on YouTube.

The Tech Stack:

Vocals: ACE-Step v1.5

Image: ChatGPT

Visuals: LTX Video + ComfyUI

The workflow is available on civitai

GPU 4070 TI super + 32 GB ram

I'm just starting out and plan to post the whole journey of building this universe on my TikTok and YouTube. Let me know what you think of the vibe!

And not for the obvious reason, like taking over my job or. It scares me how depended I am on it and how unstable it is.. ok, i mean claude in this case. I have Claude Max plan and cannot do without it. I think it is the only subscription i cannot do without anymore.. I can stop developing apps but it is fun to do.. yes i can program so not 100% vibing here but it makes life easier and everything a lot faster. But I am also applying for a job, so use cowork at the moment to update my resume to the job ad and write a cover letter.. At somepoint it was able to write both of them 80-90% ready to send out, which was pretty amazing.. only had to upload the job ad, it asked me a bunch of questions upfront and produced a pretty good draft for me to tweak a bit and done.

the same was with claude code.. i had amazing days where it thought of things i didnt think of, made beatiful code and solutions.. .. until yesterday.. monday 20th of April. I started my day as usual.. needed to apply at least for one job.. and build something in the backlog.. I started in the same way where i left the they before... and it was.... total crap!. like i was talking to a junior html programmer trying to learn dart (am building a mobile app).. on the cv/resume part exaclty the same.. a 12 year old trying to write a letter for a senior position.. thing is this happend before.. sometimes it feels AI has the monday blues, because mostly it happens on mondays.. today is tuesday and stil crap.. and it scares me.

because i know what it can do, so i don;t want to write the cover letter myself as it feels a waste of time.. but i also don't know when claude get his mojo back and write that 80% letter for me so i can just do the 20%. My brain is not wired anymore to write a full letter.. it is wired to double check and fix minor issues.. I think i more afraid of this.. becoming so dependend on AI that i cannot go back anymore to 'normal' life.. and that I cannot do without a $100 subscription but cannot depend on it also to be consistent.

Surely i am not alone in this... right?

My postgraduate project is about future design, involving soft robots and fashion design. My graduation project is about companion soft robot design (wearable), but it is very experimental and more design-oriented.

So I have been thinking about how I can enter the software robotics industry, which I have been studying design for, from undergraduate to graduate.

Do I need to apply for a PhD? As a person who has no foundation in mechanics and programming (I know that some courses can be studied online), but as a person who has focused on design for years, this span is a little too big. At present, I am concerned that MIT has a laboratory focusing on soft robotics. I notice they have developed some interesting stuff with fashion design. What is the field of work after graduation? Is there anything else?

To be honest, I feel very confused. I don't know if students with such a background want to continue to do these designs. Can I only work as an individual designer to do this kind of experimental work, but I can't get in touch with the market?

I hope that if anyone has thoughts and ideas, please share! THANKS!

There's a lot of coverage of how AI agents are being built. Almost none of it covers how they're being governed, maintained, and operated once they're deployed.

I think the reason is that the tools and frameworks for that layer barely exist yet. But the job title is already appearing: AI Director, Director of AI, VP of AI, Head of Agentic Systems. These are real roles at mid-to-large organizations right now.

I've been thinking about what this job actually entails in 2026, and it seems like 5 different functions are colliding into one role:

1. Strategy: Which workflows should be agentic? What's the build-vs-buy decision on agent infrastructure?

2. Governance: What are agents authorized to do? How do you maintain human oversight without creating bottlenecks?

3. Config management: How do you ensure agent instructions are versioned, consistent, and auditable across dozens of deployments?

4. Performance management: How do you measure whether an agent is doing its job well, especially when "doing its job" means handling edge cases a human would have caught?

5. Team coordination: Agents are touching every team. Who owns the agents? IT? The business unit? A central AI team?

Has anyone here navigated this at scale? The people building the agents seem well-represented in these communities. Curious to hear from those managing them. Newsletter for people at this layer in the comments.

I tried to find many places on youtube, civitai and in reddit but can't find a good workflow for ad creation in UGC style.

Is there any workflow where i can put my reference image, and product image and then it can create the ad (audio + video) on the prompt and text that i say it?

is there good workflow?

Perhaps I'm hallucinating as I said and contrary to what the mods might think this isn't a low effort question, I'm actively researching instances where the agent has tried to go rogue and I seem to remember reading about this particular case a year or so ago. So it'd be nice if you can help me out here.

Most of my AI video work starts with a script or a visual concept and works outward from there. This one was different. I had a finished audio track called Whispers and I wanted the visuals to feel like they were pulled out of the music rather than built around it. That meant reversing the usual workflow entirely. Audio first, everything else second.

I want to walk through the exact process because I learned a few things doing it this way that are not obvious if you have only ever worked script to video.

Starting with the audio

The first decision was format. I was working with a finished mixed and mastered WAV file. Most AI video tools that accept audio input prefer a clean stereo file at 44.1kHz or 48kHz. Before uploading anything I made sure the audio was not clipping and that the dynamic range was intact. Compressed, over limited audio tends to produce flatter visual interpretations because the tool has less contrast in the waveform to work with. Quiet passages and loud passages need to register as genuinely different from each other.

The track itself is about 29 seconds, which matters. Shorter audio gives the generation more coherence to work with. The model does not have to maintain a visual narrative across 3 or 4 minutes. Every second can be denser and more considered.

Setting the vibe references

This is the step that most people underinvest in and it makes the biggest difference in whether the output feels like it matches the mood of the track or just vaguely accompanies it.

For Whispers I built my vibe reference set around three things: a color temperature, a texture, and a motion language.

Color temperature: I wanted the palette to sit in cool desaturated tones with selective warmth in the midtones. Think overcast daylight filtered through fabric, not golden hour, not neon. I used reference images sourced from editorial photography rather than other AI video output, because AI trained on AI tends to amplify whatever aesthetic already dominates those outputs.

Texture: the track has a lot of breath and air in it. Ambient pads, very little transient energy. I wanted the visuals to feel like there was atmosphere between the camera and the subject. Slight haze, soft focus on edges, nothing that felt too sharp or too resolved. I pulled film references from slow cinema, particularly long shot compositions where the subject occupies a small part of the frame.

Motion language: the tempo of Whispers is slow and drifting. I specified that any camera movement should feel like drift rather than push. No fast cuts. I described the motion rhythm explicitly in my reference notes as something that should feel like watching water move rather than watching someone walk.

The generation process

Once the audio was uploaded and the vibe references were set, the system analyzed the track and began generating visual segments that mapped to the energy curve of the audio. The quiet opening produced wider, stiller compositions. As the track built, the visual density and motion responded to it. This responsiveness is the part of the audio to video workflow that genuinely surprises people the first time. The pacing is not something you program. It emerges from the relationship between the audio and the model.

I ran this inside Atlabs, which takes the uploaded audio and the vibe references as the primary creative inputs.

What I would do differently

The one thing I underspecified was the subject. I gave enough information about environment and mood but was vague about what, if anything, should be the focal point of the frame. Some of the generated segments were stronger for that ambiguity. Others felt unanchored. If I ran this track again I would add one clear subject reference image as a loose anchor without prescribing it too tightly.

The finished piece is 29 seconds. If you want to try this workflow the main thing to get right before uploading anything is the vibe reference set. The audio tells the tool what to feel.

What I'm building

A local RAG study assistant (Streamlit + LangGraph + Ollama) that answers Slovak-language questions about English academic PDFs. Everything runs locally — no API calls, no cloud.

Full stack:

• PDF extraction: pymupdf4llm (fast) or MinerU (slow, better LaTeX)
• Embeddings: intfloat/multilingual-e5-base
• Vector store: FAISS + BM25 (hybrid retrieval)
• Reranker: cross-encoder/mmarco-mMiniLMv2-L12-H384-v1
• LLM: gemma3:4b via Ollama
• Orchestration: LangGraph StateGraph

Pipeline architecture

Document processing — parent-child chunking

PDFs are extracted to Markdown with explicit page markers injected per physical page:

Documents are split using parent-child chunking:

python

# Parent: MarkdownHeaderTextSplitter, then merge/split MIN_PARENT_SIZE = 400 MAX_PARENT_SIZE = 2800 # Child: indexed in FAISS for retrieval CHILD_CHUNK_SIZE = 600 CHILD_CHUNK_OVERLAP = 100 

Child chunks are indexed in FAISS. At query time, matched children are expanded to their parent document for richer context. Every chunk carries page metadata (page, page_start, page_end, pages, parent_id, h1/h2/h3).

Retrieval pipeline (LangGraph nodes)

pre_retrieval → hybrid_retrieve → rerank → build_context → evaluate_evidence → generate / abstain 

pre_retrieval: classifies intent, rewrites queries 2–3 ways, detects document language. For English documents, Slovak queries are translated to English via a secondary LLM call before retrieval.

hybrid_retrieve: FAISS dense search + BM25, fused with Reciprocal Rank Fusion. Intent-aware weighting — for definition queries BM25 dominates (dense_k=120, bm25_k=20), for analytical queries FAISS dominates.

rerank: cross-encoder rescores top-35 candidates, returns top-10 with confidence score.

build_context: expands child→parent, token budget 22k chars, diversifies by source file.

generate: two-pass for English documents:

1. EN pass — LLM answers in English from English context (more accurate)
2. SK pass — separate LLM call translates EN answer to Slovak with domain glossary

Problem 1: Slovak translation quality with small models

gemma3:4b is broken Slovak words when translating statistical terminology from English. Examples:

My current workaround is a hardcoded glossary in the translation prompt:

python

_TRANSLATE_EN_SK_SYSTEM = """ ... MANDATORY GLOSSARY: - standard deviation → smerodajná odchýlka - two-sample → dvojvýberový - treatment → ošetrenie - replication → replikácia ... """ 

This works for the statistics textbook, but breaks for other domains. I tried extracting a per-document glossary at upload time via a one-shot LLM call, but the same model that mistranslates during generation also makes errors during extraction — the bootstrapping problem.

Q: Is there a better architectural approach for domain-adapted translation in cross-lingual RAG with small local LLMs?

Problem 2: Retrieval returns application context instead of definitional context

For questions like "What is ANOVA?" or "What is the significance level?", the retrieved chunks contain uses of the concept (e.g. a specific experiment table showing F-statistics) rather than the definition section (Chapter 3 for ANOVA, Chapter 2 for α).

The issue is that the concept appears ~200 times throughout the book. The dense embedding of "what is ANOVA" matches chunks that discuss ANOVA results, not the introductory definition. The reranker score for the definition chunk (confidence ~0.34) loses to application chunks in a 757-page technical book.

Example: query "čo to je ANOVA?" → retrieved chunk talks about noise level and filter type in a specific factorial experiment, not the definition of ANOVA.

My current mitigation attempts:

• Increased TOP_CANDIDATES to 35, but definition chunks still don't rank high enough
• Added intent hint in generation prompt: "Start with a direct definition" — doesn't help when the definition chunk isn't in the context at all

Q: How do you ensure definition/introductory chunks are retrieved for conceptual questions in a large technical textbook? Is there a standard approach — separate definitional index, boosting first-occurrence chunks, chapter-aware retrieval?

Problem 3: LLM loop/repetition when translation pass receives unexpected input

When the EN pass of the generation returns Slovak text instead of English (happens when gemma3:4b ignores the language instruction), the translation pass receives Slovak input and enters an infinite repetition loop, filling num_predict tokens with repeated phrases like "záverej záverej záverej...".

I've added detection:

python

def _detect_repetition_loop(text: str, threshold: int = 4) -> bool: words = text.split() for window in range(2, 5): for i in range(len(words) - window * threshold): phrase = " ".join(words[i:i+window]) count = sum( 1 for j in range(i, len(words) - window, window) if " ".join(words[j:j+window]) == phrase ) if count >= threshold: return True return False 

And language detection to skip the translation pass if the EN pass already returned Slovak:

python

def _is_slovak(text: str) -> bool: sk_chars = set("áéíóúäčšžľĺŕňťďÁÉÍÓÚÄČŠŽĽĹŔŇŤĎ") return sum(1 for c in text if c in sk_chars) > len(text) * 0.02 

Q: Is there a more robust way to enforce output language in a two-pass generate→translate pipeline with a 4B model? Would a structured output format (JSON with a language field) help catch these failures earlier?

Problem 4: Source attribution fails cross-lingually

After generating a Slovak answer from English documents, I try to identify which source chunks contributed using word overlap:

python

answer_words = set(w.lower() for w in re.findall(r'\b\w{5,}\b', answer)) doc_words = set(w.lower() for w in re.findall(r'\b\w{5,}\b', doc.page_content)) overlap = len(answer_words & doc_words) 

The overlap is consistently 0–1 because Slovak and English share no words. The fallback return [scored[0][0]] does return a document but doesn't meaningfully identify which chunks contributed.

Current workaround: lowered min_overlap=2 with a hard fallback to the top reranked document. But this means source citations are based on retrieval rank, not actual contribution.

Q: What's the correct approach for cross-lingual source attribution? Use reranker scores directly as a contribution proxy? Embed the answer and compute cosine similarity against chunk embeddings?

What's working well

• Two-pass EN→SK generation significantly improved Slovak quality vs single-pass
• Hybrid BM25 + FAISS with RRF works well for specific factual queries (confidence > 0.8)
• Parent-child expansion gives better context than flat chunking
• MinerU slow mode extracts LaTeX correctly from equations (pymupdf4llm garbles them)
• Per-page image rendering allows showing exact PDF pages alongside answers

Code

Full rag_graph.py, document_processor.py, and vector_store.py available on Pastebin:

https://pastebin.com/37iDfSS3

https://pastebin.com/ybszN3sK

https://pastebin.com/3WK6PFw2

Any advice on problems 1 and 2 especially welcome — the retrieval failure for definitional queries in large technical books feels like a fundamental architectural issue I'm not sure how to solve without a separate index or metadata-based boosting.

Ep. 7: HE CAN TASTE THE GOAT IN THE AIR. 🌬️

I,e you can make the best argument for flat earth even though the best argument is still stupid beyond comprehension. You will not however understand why you're wrong or why this is the best argument it will just come out naturally. Like if you argue that james tommas shat in his house in 1700 or something if he didn't objectively do that,you will not know what actually happened.

Teacher:Class,what’s Question number 1?

Students:It’s 4!

(Jack comes in after going to the toilet)

Teacher:What did you do to waste for 10 minutes?

Jack:I went to number 2.

Teacher:Ok, what’s number 2?

Jack:Poop.

Hey everyone 👋
Job hunting is exhausting 😩. So I built an autonomous pipeline that does the heavy lifting for me.

🔄 What it does:
Runs every weekday at 9 AM and 5 PM. Here's the full flow:
1. 📖 Reads my LinkedIn profile + CV via Jina AI
2. 🧠 Google Gemini analyzes my profile → extracts roles, skills, seniority, salary expectations
3. 🔎 Generates 3 targeted job search queries
4. 🕷️ Apify scrapes fresh LinkedIn job listings
5. ✅ Deduplication — skips jobs already seen (tracked in Google Sheets)
6. 🎯 Gemini scores each job 1–10 based on fit
7. 📊 Filters jobs with score ≥ 6
8. ✉️ Generates a personalized cold email per job
9. 💾 Saves everything to Google Sheets
10. 📬 Sends me an HTML email digest with matched jobs + ready-to-send cold emails

🛠️ Tech stack:
- ⚙️ n8n (self-hosted or cloud)
- 🔗 Jina AI (scrape LinkedIn profile + CV)
- ✨ Google Gemini 2.5 Pro/Flash (AI scoring + profile analysis)
- 🕷️ Apify (LinkedIn job scraper)
- 📊 Google Sheets (job tracker + dedup store)
- 📧 Gmail (daily digest)

💸 Totally free to run — all services have free tiers!

💬 Looking for your thoughts
- 🕷️ Better alternatives to Apify? (can be slow/rate-limited)
- ✍️ Ideas to improve cold email quality ?
- 🔁 Anyone running similar setups — what did you change?
- 🌍 Suggestions for other job boards? (Indeed, Naukri, Wellfound ?)

🔗 GitHub: https://github.com/CoderOO7/n8n-automate-job-apply
Workflow JSON imports directly into n8n — no code required 🙌

Drop your thoughts below 👇 Happy to answer questions!

But I’m slowly getting over it. . .

The voices were feeling left out, and started making dangerous suggestions.

Looking through the Manager and custom nodes, I haven't been able to locate an image converter. With all the PNG files adding to space, O would love for a node to automatically convert PNG to Jpeg or something similar, that would reduce the size without the loss of quality. Is there such a thing?

I mostly use images to make scenarios for RP, different characters and monsters for encounters.

my first instinct was joan of arc but i have no idea. the ring has a paper clip attached to fix it to whatever it is its for. it wasn’t super heavy but had more heft than an christmas bauble

My friend discovered this on the sand a couple years ago on a beach located somewhere on the west coast of the United States. Either in NorCal or Oregon, not entirely sure which. We’re wondering if it’s some sort of fossilized specimen or something because we’ve never seen anything like this before. It’s relatively light compared to other rocks of a similar size and definitely feels fragile. Thoughts?

Hey everyone,

We’ve been building Stanley for X, an AI built to help people create better content for X without staring at a blank page for hours.

Background: I'm a Twitter ghostwriter and I help founders grow their accounts.

One founder I helped grow from 0 to 10k followers in the past 3 months asked me to help him build my knowledge into an AI, so anyone can get the same results... but without spending thousands on a ghostwriter to do it for them.

So in the past 10 days, we locked the f*ck in and built an AI of Content from absolute scratch (the entire process will be released on YouTube soon as well).

Coolest thing though...

Within the first 24 hours, we had our first 5 paying customers.

The core idea is simple:

Most people do not struggle on Twitter because they have zero ideas.

They struggle because content creation is a full stack problem.

You need to know:

• what to post
• how to angle it
• how to structure it
• how to make it fit your niche and voice
• how to stay consistent long enough for it to actually compound

That is where Stanley comes in.

It is designed to help with the full content workflow of a real ghostwriter, not just spit out random tweets.

It can help you:

• research topics and angles
• turn rough ideas into sharper post concepts
• plan content around your goals
• write drafts faster
• help you stay consistent with execution

So instead of opening ChatGPT and getting generic content, the goal is to have something that feels more like an actual AI Head of Content for your X account.

We've just launched this on Producthunt today and you can try it for free using the link below. If you do end up liking, please share a comment with us there to support the launch.

https://www.producthunt.com/posts/stanley-for-x

Just know..

We specifically built it around the real systems I use to grow accounts, not just generic AI prompting. The vision is to make content creation less chaotic, less mentally draining, and a lot more strategic.

If you create on X, or want to grow there, I’d genuinely love your feedback on this.

Happy to answer questions, show how it works, or hear what would actually make a tool like this useful for you.

I don't know how can I upload my code from a computer(a desktop one) to my arduino. I'm currently using my phone as an ide with the help of arduino droid.

I’ve been thinking about changing my hairstyle but didn’t want to risk a bad cut, so I tested a few AI tools to see what actually looks close to real life. Most of them still feel a bit “filter-like,” but here’s what I found:

TheRightHairstyles - This was the one I started with, and honestly it set the bar. It’s more focused on helping you choose a style rather than just generating a random look. You can quickly compare different cuts, see what fits your face shape, and the results don’t overly distort your features.

FaceApp - Still one of the fastest options out there. Good for quick previews and your face stays recognizable, but sometimes the hair itself looks a bit too polished or artificial.

YouCam Makeup - It gives more control over shades, though the interface takes a bit of getting used to.

Fotor AI Hairstyle - Has a wide range of styles, but results can be inconsistent. Some look decent, others feel less natural.

Overall, none of these are perfect yet, but they’re useful to avoid going completely blind into a haircut. TheRightHairstyles if you want something that actually helps you decide and compare styles, FaceApp for quick results, YouCam if color matters, Fotor if you just want to explore more options.

Has anyone found something that actually nails photorealism? Still feels like AI is close, but not quite there.

blind_eval_output

Built an n8n eval workflow that A/B tests any prompt through plain GPT-4o vs GPT-4o + a reasoning scaffold, judged by a blind Gemini evaluator

Solo founder here. I've been building a cognitive infrastructure API (Ejentum) and needed a way for builders to evaluate it on their own agent tasks instead of trusting my benchmarks. So I published the eval as an n8n workflow.

What it is

A three-agent n8n workflow. You paste any prompt in the chat trigger. The prompt fans out through two identical GPT-4o agents (one plain, one with an Ejentum reasoning scaffold injected via an HTTP tool). A blind Gemini Flash evaluator scores both responses on five dimensions (specificity, posture, depth, actionability, honesty) and returns structured JSON with a verdict.

randomized_output_naming

simple eval tool, 3 api keys and type in, universal for any type of evaluation. available on github

The evaluator is allowed to return "tie" and regularly does. Point is you test on your own tasks and decide.

What it's actually testing

• Whether the cognitive scaffold changes output posture on a given task, or not
• Whether the scaffolded agent engages the specific claims in your prompt or stays generic
• How the scaffold affects sycophancy, depth, and diagnostic procedure
• Whether different harness modes (reasoning, anti-deception, memory, code) stress different task types. Mode is editable in the HTTP tool's JSON body

The diff is often subtle on easy prompts and more pronounced on dual-load prompts (emotional + cognitive claims mixed), advice prompts with a buried false premise, or multi-variable causal reasoning. Low-complexity single-turn tasks often produce ties because GPT-4o handles them well without a scaffold.

Where you might apply this pattern

• Customer support agents: test whether the scaffold reduces rubber-stamping and increases specificity on customer complaints
• Code review or diagnostic agents: test whether it catches the failure modes you actually care about
• Content or research workflows: test whether it reduces generic output on your topics
• Multi-agent systems: wrap any single agent call in the fork to see the effect before integrating permanently
• Prompt engineering A/B tests: measure the effect of a cognitive layer against your own prompt iterations

Setup

1. Import Reasoning_Harness_Eval_Workflow.json
2. Set three credentials: OpenAI (both producer agents), Google Gemini (blind evaluator), Header Auth for the Ejentum API (free key at ejentum.com, 100 calls)
3. Paste a prompt in the chat trigger

Workflow diagram:
[attach screenshots/eval_workflow.png]

A vs B output from one run:
[attach screenshots/A_vs_B.png]

Blind evaluator verdict JSON from the same run:
[attach screenshots/A_B__blind_eval.png]

Workflow JSON, READMEs, and a TypeScript port for IDE setups (Antigravity, Claude Code, Cursor): https://github.com/ejentum/eval

I have a large number of blog posts scraped from the various sources. I'm tasked to classify these into "relevant" and "irrelevant" depending on if they are related to specific medical area.

I'm already doing early classification using simpler techniques like looking for specific keywords (adhoc made up example - a post containing `saturn rings` gets classified as `irrelevant` and doesn't need LLM driven classification).

The posts that do not get classified from the above need to pass through LLM based classification. What models offer decent accuracy without costing a bomb (I've got more than 20k posts each with 1000 - 5000 words in length to classify). Speed isn't a major factor since I'm ok to let this run for a long duration.

https://preview.redd.it/y54gy6uh0qwg1.jpg?width=706&format=pjpg&auto=webp&s=524690b72d752445130873b08789f2d6f3ba808c

https://chatgpt.com/share/69e8a636-7a54-8320-8812-c17f8760421c

I've been using Gpt as a memory keeper and it suddenly forgot everything i've mentioned to it. The memories are still there but it seems like it cannot access them. I tried to delete all of the memories and make it relearn everything but the second i open a new chat, it forgets everything again even though the information is in its memories.

This only happens to one account so i have no idea why this is happening. I tried deleting the app and reinstall it but it didnt work either. Does anyone have the same problem as me or is it just my account?

Turned on confidentiality mode, and pulled a full Facebook Page audit in under 60 seconds.

Top questions. Engagement stats. A client-ready report saved straight to Drive.

No Business Suite. No scripts. No export spreadsheets.If you run client pages, this changes the job.

Hope this is valuable to someone as this is only one of many services im able to offer to clients with this stack, If its for you then great if not then all good either way.

Lets keep building and have fun doing it (Leading Value First)

My AI workflows are getting harder to monitor as usage grows. The biggest issue is not building the agent — it’s knowing what’s actually costing money.

How are you tracking:

• cost per agent
• cost per customer
• traces and logs
• token usage spikes

Would love to hear what’s working for you.

Title: Finally even free users can track their Claude usage!!

Body:

If you're on the free plan, Claude doesn't show you anywhere how close you are to the 5-hour or weekly limits - that "Plan usage" page in settings is paid-only. You just hit the cap out of nowhere mid-conversation and get told to come back in a few hours.

So I added a panel to my Chrome extension (Claude Toolbox) that pulls the usage numbers Claude already exposes and renders them for everyone in the extension's settings modal:

• Current session (5-hour window) - % used + exact reset time
• Weekly limit - % used + reset day
• Paid users get a one-click shortcut to Claude's native /settings/usage page instead (no point duplicating what they already have)

The new Plan Usage panel inside Claude Toolbox settings (free account).

Extension is free. All data stays local - the usage numbers come straight from the endpoint Claude's own UI uses, nothing goes through any backend of mine.

I am building one app, nothing new, just for fun.

Task is simple i just need to enhnace of rephrase the input it not need to add any new data kind of grammer and setence correction

I tried phi-3 model which is doing great job but the problem is its slow. Its taking around 15-20 seconds even though my phone is Vivo X300 Pro. So i wanted a suggestion which model i should use for this job

Just wanted to share a project I've been refining: "Arbiter." It's a local proxy that translates Anthropic's streaming format to OpenAI's format in real-time.

The main goal was to make Claude Code’s agentic features (tool use, disk access, terminal control) compatible with free cloud providers. I added some logic to handle the specific crash conditions that usually happen when people try to use LiteLLM or similar proxies directly with the Claude CLI.

Current status:

• Kimi K2 (0905) and Mistral Large 3 are confirmed stable.
• Llama 3.3 70B works for most logic tasks.
• Includes a parallel availability prober at startup.

I'll post the repository info in the comments for those who want to check it out

TL;DR: Vibe coding is great for PoCs and miserable for real projects. I led 55,000 lines of code be written by Claude in about eight weeks and learned that skills and claude.md are not sufficient. At the bottom of this post there's a plugin that packages the methodic I developed. It gives traceable, fully documented implementations. Add the plugin with two commands and it's in your project.

How this started

Starting this year I heard about OpenClaw. Skyrocketing. And Peter Steinberger was fame "in a minute". Obviously right point, right time. Well deserved I guess. And then everything starts to move with light speed. Demos everywhere, people were building apps in twenty minutes, and I was sitting there thinking if I didn't figure this out soon I'd miss whatever was happening. Needed to get my hands dirty. Something with real stakes, something I could actually learn from.

The hypothesis was simple. All about that was AI. Thinking about all the streams and virtual assistants doing great things, what do I need? Ticket to PR. An agent that reads a ticket, understands it, changes the code and finally opens a pull request. Controlled implementations to move the easy or medium complex tasks to an AI. What does it mean to set this up?

Trying to move fast while hitting walls

Bought Claude max. I considered 110 Euro/ month to be pretty expensive, but for a month at least? I started to let Claude implement it. Due to, I wanted to see if Claude is really able to do it autonomously. And don't write a line. I didn't want to "speed up by not knowing". And I do not tell the "AI takes over all developer jobs end of the year" story. I didn't believe in it anyway, this was my test balloon to prove it.

So let Claude do the job.

Used ZED, JetBrains and VsCode as IDEs. Sticked to VsCode finally. It has the same problems as all the others anyway. Sometimes it "just gives up". Or Claude does not response anymore. When having talked a lot to Claude to explain my next feature, this is really time consuming when the context is gone. Starting all over again when having restarted the IDE, was annoying. Really annoying.

Another thing I did miss was kind of a structure. I need to tell Claude the folder structures, the separation of code in files, to know where to put what. How to split things. Do it SOLID, DRY and tell don't ask.

So do what all the other did as well, I guess. Add CLAUDE.md with instructions. coding-principles.md with the rules. That should do it, I thought in the first run. And the second.

Surely, it didn't work out.

This is not good enough

When there is feature after feature, how does Claude know where is what? How do I know what is actually there to understand what is in place?

Putting lots of tokens he'll find it and can tell me. This does not convince me as a solution. Sure, Skills and coding principles help. After some features I asked Claude: We have this rules in coding principles:

• 120 lines of code max per file
• 20 lines of code max per method
• only one type per file (interface, class, enum,...)

"Claude, please calculate all file sizes and let me know where sizes exceeded the limit". I did this multiple times and it was everytime the same. Files exceeded 500 lines of code.

I asked Claude why and he answered "that is boil the frog". Things are going to be added and the files grow. This is really a difference to how I program. I don't just add. If something exceeds a certain degree of complexity I am going to change my plan. One reason why Claude will not directly replace everybody, I guess.

There are regular refactoring sessions to split up the code matching the conventions.

But anyway I needed kind of a plan that is written down. Talking to Claude to let him "just do something" always ends up in undocumented somethings.

So where are my plan to control the flow and to structure it for my AI? On the one hand, I'm trying to tame the beast, but I still have no idea how to handle it.

The phase, the context and the reasoning

The structure I ended up with wasn't designed. It evolved.

First I just had too many features and working on them in parallel meant juggling multiple Claude sessions, each with its own memory of what we were doing. I experienced that switching contexts between Claude session even if I don't write the code is pretty exhausting. I didn't expect this.

Anyway, I need plans. I disussed with Claude and let him write down what we are going to do. Just md, like he wanted. Then a context.md. This context would just have the summarized information of what the program is about and what plans are active, done or in planning. I didn't call it plan, but phase. Context is read right from claude.md instructions. Full phase information only when needed.

Phases got long and therefore also expensive. I didn't recognise this in the first run. When I had 70 plans with 120.000 tokens, it grew to be a challenge not an advantage. Again, letting Claude read all the phases consumed to many tokens and got slow.

Anyway I didn't like these phases. Lot's of explanation and even code samples. Why should this be a benefit? I anyway don't read phase documents, Claude does. Let's do "key=value". Use YAML with a schema. Claude reads YAML faster than prose, and I can validate it. Claude consumes differently than a human does.

And while we are talking about phases and optimization. Usually decisions and reasoning is taken when defining the phases and make the plan. When stucking with a complex piece of code that has a certain age, I always asked for the "why?". Certainly I do not find this in code, maybe in developer minds. Claude can automate this.

Three things that actually worked

After 90+ phases it came down to three artifacts:

The phase. Short & structured. A summarized, AI understandable artifact that tells the complete story about the next thing to be done. A schema that can be followed that phases look comparable consisting of goal, decisions, steps.

The Context. A short context.yaml at the project root. A summarized picture of the architecture, the stack, the current state of the software in terms of phases. Again a yaml file that follows a schema. The agent reads it before every session. Following this, Claude has an overview about the software with less than 1000 tokens.

The reasoning. Claude is forced to write the architectural choices of phases to decisions.md. This is the "why". As AI will not complain about the time it needs to document like most the developers including me, documenting the why is easy. Never had reasoning in code that makes understanding the decision tree of the code that easy.

The Idea

I now have 90+ phases used in my own implementation. At some point in time I realised, it does not make sense to leave it buried deep in this project, so I extracted it.

It got its own github repository, I added a Claude Code plugin for easy usage. Bootstrap a project, some phase management while decision logging and methodology updates will be part of the skill set and run automatically. Two commands to install:

/plugin marketplace add holgerleichsenring/specification-first-agentic-development /plugin install spec-first@specification-first-agentic-development 

When you want more details have a look here:

• GitHub: Specification First Agentic Development.
• Agent where the implementation had been extracted: Agent Smith
• Blog post: Next Level Vibe Coding

short post says it all; They are much faster, not smarter. Scale it in human time, it gets beaten at everything, ever.

prove me wrong.

The "Goldfish Problem" is expensive. I decided to fix the plumbing.

Most Claude implementations leave 90% of their money on the table because they don't optimize for Prompt Caching. I’ve been running a personal agent in my Discord for months that manages my AWS infra and codebases, and I finally open-sourced the harness, which I've named Galadriel after my main personal assistant.

The Stats:

• Cost: $10 for every $100 you’d normally spend (Tested against OpenClaw/Cursor workflows).
• Speed: 85% drop in latency. 100K token context goes from 11s to <3s.
• Memory: Integrated MemPalace for permanent, vector-based recall that doesn't break the cache.

The Technical Stack:

• 3-Tier Stacked Caching: Separate breakpoints for Tool Definitions, System Prompts (CLAUDE.md), and Trailing History.
• Privacy: Built for private subnets. No middleman, no message caps, just your API key and your rules.
• Ethics: Baked-in Karpathy CLAUDE.md guidelines to kill "agent bloat."

If you’re tired of paying the "Context Tax" just to have an agent that remembers who you are, here you go. It's of course customized (Discord) for my needs but the point is Galadriel runs like an absolute dream, never forgets, maintains engineering principles and much more. Your feedback most welcome!

GitHub (MIT License): https://github.com/avasol/galadriel-public

Dont get me wrong - I think its probably the most interesting and useful release from Anthropic in a while (for my specific use of the Claude Models), but damn this thing is either extremely thirsty or the design limits are incredibly small.

I had it mock up a total of 3 landing pages (of which 1 had a few iterations) - weekly limits gone. By the time a pop up came up saying I am using extra credits, it had already eaten close to 4$.

Again - the designs are actually quite good, way better than other LLMs, but damn thats an even thirstier version of 4.7.

https://preview.redd.it/qxuzc7eqrpwg1.png?width=2220&format=png&auto=webp&s=55892d817f8603d798c340e020d11f560ddf0a8f

Hi folks; I'm planning to get claudecode 5x; I'm a full stack dev building my micro-sass. Till now I build it with Codex 5.3 OpenAI and Kimi 2.5, GLM5.1 on Ollama Cloud.

I was thinking maybe I can start using CC 5x plan; but I'm not sure how easily i hit the 5 hours wall; and maybe weekly wall.

Any experience you like to share?

So I kept getting mediocre responses from ChatGPT and Claude, and after way too long I realized my prompts were just bad.

Not "wrong" bad, just vague. No context, no structure, no clear ask. The AI was doing its best with garbage input.

I tried to fix my habits manually. Didn't stick. So I built a small chrome extension that does it automatically it intercepts your prompt before you send it and rewrites it into something structured and specific. Works on chatgpt for now.

It's rough. Probably has bugs I haven't found yet. The edge cases are definitely not handled. That's why I'm here.

I need 10–15 people who actually use AI tools daily to:

• Use it for a week or two
• Tell me what's broken
• Tell me what feels off even if it technically works
• Be honest (harsh is fine, I'd rather know)

If you're the type who notices small UX details or has opinions about how AI should behave that's exactly who I want.

In return you get a full year of free unlimited access. No catch, just fair trade for real feedback.

After months of development, I shipped Vault Therapist — an Obsidian plugin that uses AI to analyze your entire note vault.

The problem: knowledge management tools help you capture information but don't help you understand what's already inside what you've captured. Your vault is the accumulated map of your thinking — usually larger and more fragmented than you realize.

The solution:

- Finds orphan notes and suggests specific [[wikilink]] connections

- Detects contradictions between notes on the same topic

- Identifies topics you reference but never developed

- Generates a weekly vault health report with an AI-written narrative

Tech stack:

- TypeScript, esbuild, Obsidian Plugin API

- Supports 6 AI providers: Ollama, LMStudio (both local), OpenAI, Anthropic, Gemini, OpenRouter (all BYOK)

- TF-IDF fallback when the provider doesn't support embeddings

- Minimal Express backend on Railway for license validation

- Lemon Squeezy for payments (one-time $15)

- BUSL-1.1 licensed, source available on GitHub

Built solo over ~2 months with heavy use of Claude Code. Launched last week. Currently awaiting Obsidian community plugin store review but already sellable via GitHub direct install.

Website: https://vaulttherapist.com

GitHub: https://github.com/rzgrozt/vault-therapist

Happy to answer questions about the build, the pricing decision (one-time vs subscription), or the indie launch process.

This book seems to be good read

5 min quick learning on how to do prompt better.

https://www.amazon.com/dp/B0GX37391P

https://amzn.in/d/0gWyY0HE

its worth it

Same prompt, same seed.

Result image with Workflow here (complex)

In the last two days, ChatGPT feels like it improved a lot. The answers are clearer, the writing is smoother, and overall it just works better.

Before this, I thought ChatGPT was falling behind and that people would switch to Claude for good. But after using it again since yesterday, my opinion has changed. It feels like it is catching up fast.

I have been using both the free and paid versions of ChatGPT for over a year, so I have seen how it has evolved. I really do not want to rely on Claude all the time. It is expensive and the usage runs out quickly.

Now, I feel hopeful again. ChatGPT seems like it is getting back on track and improving in the right direction.

I've only seen screenshots of this! It has a tool end_conversation and it WILL use it if you insult it. I didn't think Anthropic would implement such a tool. But here I just asked nicely for the screenshot and it did it 🤷.

I spent the last year building Eurora to not have to explain the context of what I am doing, every time I wanted to ask a question.

Eurora is a cross-platform application that creates a custom network layer between itself and every single browser in existence and runs on Linux, macOS and Windows.

This allows the AI assistant to interact with the browser and see the whole website. As well as run mcp-like commands against the website you’re currently on.

I also built a number of custom adapters. For example, asking a question about a video on YouTube allows the AI to retrieve the transcript of the video you’re watching, as well as the frames and other information like the current timestamp. The current timestamp also allows the AI to then understand the line that the person in the video just said. We also have adapters for Twitter and Google Docs right now to be able to retrieve structured data. Eurora works on every single website already by using standard calls and strategies.

Eurora is built to run on a dedicated machine and has a separate server component for things like cron-jobs, indexing as well as all kinds of various processing in the future. The application is local-first and can be run on local hardware without ever touching external servers.

If you want to use certain models that are too big to run locally, then you can connect to our Sovereign European Cloud. We specifically designed the server code in such a way that you can see exactly how your data is accessed (spoiler: it’s not). The goal here is to provide a fully secure and private cloud LLM environment that we can prove is fully secure.

You can find out more about Eurora below:

Video demo - https://youtu.be/fj8cmNu_c5Y

Github - https://github.com/eurora-labs/eurora

You can download our app for every platform and every browser below. You get 500,000 cloud tokens for free when creating an account, it would be immensely helpful if you could tell me what you think of Eurora.

Website - https://www.eurora-labs.com

Download link - https://www.eurora-labs.com/download

I feel like OpenAI still have some work to do. What do you think?

After analyzing dozens of agent failures, it's clear: the problem isn't the LLM, it's the visual data. Most agents rely on screenshots, which are brittle and imprecise.

I've been working on AICommander, which takes a different approach by interacting with the OS via system-level automation and UI bindings. It doesn't just 'guess' where a button is; it knows.

Whether it's legacy Windows apps with no API or complex file orchestrations, the goal is reliability over hype. Curious to hear what others are using to solve the 'brittleness' problem in 2026!

Morning Everyone!

All pretty standard changes - except a huge bug was fixed for Opus 4.7 which hopefully should result in some pretty big improvements.

I normally just link the full notes but I think this one note I have to include:

Opus 4.7's 1M context window was being wasted. Since Opus 4.7 shipped in 2.1.111, context calculations assumed a 200K window. This meant /context showed inflated usage percentages and autocompaction triggered roughly five times too early, effectively capping usable context at 200K. If you noticed Opus 4.7 sessions compacting much sooner than expected, this is the fix.

Kinda insane, they basically accidently self-nerfed Opus 4.7 in CC by telling it that it only had a 200k context. Only took 6 versions to find this out!

This fix, in theory, should result in some major Opus 4.7 1M quality improvements, especially on the larger codebases (which it is designed for).

Full notes: https://www.lukerenton.com/matins/2026-04-22

What is said and what actually launches can be different. It looks like I'm in the 2% for the Pro subscriptions. Anyone else also seeing this?

Hey everyone,

Ever since the day Google announced TurboQuant, I've been following the news about its extreme compression capabilities without noticeable quality degradation. I see it mentioned constantly on this sub, but despite all the discussions, I'm honestly still a bit confused: is it actually applicable for us right now? And if so, how?

I recently saw an article/post where someone applied this TQ quantization directly to the model weights. They managed to get Qwen3.5-27B running at near-Q4_0 quality, making it about 10% smaller, which finally allowed it to fit comfortably on a 16GB card (specifically an RTX 5060 Ti). This is huge for us with consumer GPUs.

However, since TurboQuant was initially heavily pitched for its efficiency with context and memory, my main question is about the KV Cache.

As we know, context length is the real VRAM killer. So my doubts are:

1. Can we currently apply TQ quantization to the KV cache when using llama-server (llama.cpp)?
2. If yes, how do we enable it? Is there already a CLI flag similar to --cache-type q4_0 / --cache-type q8_0?
3. Or is this strictly limited to model weights right now, and we are still waiting for an official PR/release from the llama.cpp team to implement TQ for the KV cache?

I'd love to hear if anyone has tested this or knows the current development status. Thanks!

I've always found ChatGPT to be really positive and that's a nice thing.

However - come on - please.... I've not planned and budgeted well enough to have a comfortable retirement. It might be pretty miserable. But good old ChatGPT can't bring itself to say "You're screwed. Get used to eating Pot Noodles". Instead, it focuses on the posistive. My pension payments will be so low, I won't pay much tax...

Prompt: Create a single wide, highly detailed, photorealistic illustration showing all Presidents of the United States in strict chronological order, from George Washington to the most recent president.

Each president must be represented as a unique, lifelike cat with realistic fur, anatomy, and lighting, while subtly incorporating recognizable human features (hairstyle, facial structure, expression) and iconic clothing or symbols associated with that president.

Composition:

Arrange the cats in a clean horizontal timeline or slightly curved gallery layout.

Each cat should be fully visible and evenly spaced.

Ensure historical progression is visually clear from left (earliest) to right (latest).

Per President Details:

Add a small number in the top-left corner of each cat (e.g., “1”, “2”, “3”…).

Include the years of presidency beneath or near each cat in a subtle, elegant font.

Below each cat, add a short, witty, cat-themed quote referencing their presidency, personality, or historical actions (light humor, clever wordplay, no modern slang).

Style & Quality:

Ultra-photorealistic (like a professional wildlife photograph)

Sharp focus, studio lighting or soft museum lighting

Rich textures in fur and fabric

Consistent scale and perspective across all figures

High resolution, cinematic detail

Background:

Neutral, museum-like backdrop or softly blurred historical setting

Avoid clutter—focus attention on the cats

Tone:

Playful but respectful

Historically recognizable

Subtle humor, not cartoonish

Optional Add-On (if your tool supports it): “8k resolution, hyperrealistic, depth of field, global illumination, physically accurate lighting”

Is anyone using claude code via Azure foundry? Is it possible to operate CC on that basis? Paying via Azure costs?

Its not perfect, but its pretty good imo. What do you guys think?

Like a lot of you day-one degenerates, I’ve been daily driving Opus 4.7. I use it for a bunch of stuff, but mainly coding.

Every time I open this sub, my blood pressure spikes. It’s just an endless doomscroll of posts crying about how absolute trash it is, how it’s been nerfed to the ground compared to 4.6 or even 4.5.

Honestly? My experience is the exact opposite. For me, it feels like a massive leap forward for complex tasks. It’s been nailing heavy implementations and nasty bug fixes with almost embarrassing ease. And don't even get me started on the UI/UX side—it’s throwing out legitimately big-brain, everyday usability solutions that I hadn't even considered.

So it makes me wonder: is the performance just horribly inconsistent and I'm getting insanely lucky? Or maybe it's just super finicky, and my prompting style happens to hit the sweet spot for 4.7 better than it did for 4.6? I genuinely don't know, but for me, the glow-up has been real. Probably the biggest quality jump we've had in a while.

The one thing I will say for sure is that I absolutely had to nuke the "Super Power Planning" skill. The output with that turned on was an absolute dumpster fire—it would generate plans inside of plans inside of plans, churning out a 10,000-line master plan just to write 5,000 lines of absolute spaghetti code.

But once I started stripping away the old skills I used to rely on, it turned into an absolute beast.

Thoughts? Am I totally alone in this, or is anyone else having the same experience?

Been using GPT for a year and a bit now, I talk to it basically everyday talking about my steps, meals, exercises and weight, it’s given me the tools needed to loose close to now 31KG and honestly without it I would still be 122KG or more or even not here.

Anyone else used it for similar life changes?

I am currently delving into the world of game development in Unity using AI, more specifically Claude Code. Before making this post, I have already made a rough test (MegaBonk lookalike) with relatively small effort using Claude Code, launched through Ollama, using the GLM 5.1 model.

I have now prepared a completely full game idea with documents like a design bible, technical document and more to ease the work of CC. I am just to decide on the model to use.

Is video game programming in Unity something that would be called a large codebase, where models like Opus 4.7 and similar are required, or can I get by with something simpler? Would appreciate some tips, maybe from people doing the same thing.

For reference, I am quite satisfied with the work that GLM 5.1 did, I had a controllable player model, auto attack weapon, enemies spawning in waves, xp gem drops and level up screen with selectable upgrades, etc.

Hello! We're a family which uses chatgpt, we currently have 3 plus subscriptions. We use it for work and privately, thus we buy it as a company. What advantages or disadvantages would be there when switching to a business plan? It seems to be cheaper. Thank you!

It appears that Cowork, which didn’t persist anything on Anthropic servers (like the normal Claude Chat), can now be configured to use AWS Bedrock, as opposed to using Anthropic directly.

This is nice on one side, for enterprises whose CISOs are too afraid, but!

One thing I’m trying to understand is whether it could be integrated to any Local LLM proxy.

That’s a real game changer if so. Using their harness but on our own infrastructure is insane.

I am looking for projects that use or implement AI workflows.

What I mean by AI workflows are determined steps in a business process. Those steps might be AI processes, but there should exist some sort of determinism on how those steps are realized. Like a chain of steps you could do with a langchain or langgraph.

I am looking to know more about those techniques, best practices, limitations and so on.

Please reach out!

My Linux/Fedora Local Ai performance is trailing Windows massively? Are there specific ROCm environment variables or memory management tweaks for RDNA3 that I'm missing?

Fedora 44 Workstation AI Performance

Issue: Sub-optimal AI throughput on 9950X3D/7900 XT (worse than Windows baseline).

1. Hardware Environment

• CPU: Ryzen 9 9950X3D (Zen 5, 16c/32t, 3D V-Cache on CCD0)
• GPU: Radeon RX 7900 XT 20GB (RDNA3, native gfx1100)
• RAM: 64GB DDR5 5600MHz
• OS: Fedora 44 (Kernel 6.19.10-300.fc44.x86_64)
• Stack: Wayland / amdgpu / ROCm (bare-metal)

2. Current AI Stack Configuration

The system uses CLI Ollama and with a Podman-based Open WebU both return similar performance small improvements in Terminal.

Ollama Environment Overrides (/etc/systemd/system/ollama.service.d/override.conf):

Ini, TOML

[Service]
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_CONTEXT_LENGTH=8192"

Model Strategy:

• Primary Model: Gemma 4 26B (17GB)
• Target Performance: 90+ tok/s eval (GPU-resident) ( Windows is already 95-99)

3. Applied Kernel & Hardware Tunings

• V-Cache Optimizer: Active service biasing scheduler to CCD0 (cache mode).
• CPU Driver: amd-pstate-epp with performance governor/EPP.
• Sysctl: vm.swappiness=10, vm.vfs_cache_pressure=50.
• GPU Power: Reaches ~2850MHz / ~225W+ under ROCm load.

4. Known Constraints (Explicitly Not Applied)

• mitigations=off: Not applied for security reasons.
• Transparent Huge Pages (THP): Set to madvise default.
• Ollama is running bare-metal to avoid container overhead on the ROCm path.

Comparison Data

Any help or suggestions? Feel more and more I may have picked the Wrong Distro for AMD?

Every time I prompt, the first pic is perfect, and then it becomes worse and worse...
here is my prompt :
authentic candid iPhone photo, real life moment at a French campsite clear view of someone proudly wearing Crocs with white socks, standing casually near a campsite table group reaction around: people laughing, one shocked, one taking a photo main character fully confident, relaxed body language background: apéro setup, snacks, camping chairs late afternoon warm light imperfect framing, slightly zoomed, like a spontaneous capture vertical 4:5

Has any one else faced the issue, where the model keeps responding a with a repeated text/tool call without ever stopping ?

Using this attached config.

Mainly just looking to get more image gens instead of only 2 or 3 with free. Do you get much more with go?

For 1080p 9:16 aspect ratio image generation. How long would it take to generate an image? Thanks

https://preview.redd.it/tt0ztsgkmpwg1.png?width=1123&format=png&auto=webp&s=55bde386f2a4074471dc472216bfd51e8944e398

My excel lagged, so I just put it on Claude real quick.
The number doesn't seem right to me so (bcs I know the rough estimate). It supposed to be 47,736,197.

Claude has been so helpful for my work.. I'm just wondering why it can't do basic math properly at what other task I shouldn't rely Claude on. Can any AI expert here tell me?

LEADD is now live in beta. The pitch: you're the team lead, AI agents are your dev team. The clue's in the name.

The whole thing is built around a simple idea: the ticket system exists to make you think before you build. Most AI coding tools encourage you to fire off prompts and see what sticks. LEADD makes you scope the work properly first (what you're building, why, and what "done" looks like) before any agent touches the codebase.

The flow is built around human checkpoints, not autonomy:

1. You write the ticket. Acceptance criteria, scope, the lot. This is where you decide what's actually worth building.

2. An Architect agent proposes a plan. You review and approve before any code is written.

3. A specialised implementation agent (Frontend, Backend) picks up the approved ticket and writes the code on a feature branch.

4. A Reviewer agent automatically picks up the PR and does a first-pass code review. Flags issues, suggests changes, leaves comments.

5. You make the final call. Merge it, or send it back with feedback for the implementation agent.

Every step where judgement matters, a human is in the loop. Agents do the heavy typing and the first-pass review. You make the calls.

It connects to your existing Claude Code subscription via MCP, so if you're already on Claude Max, the only new cost is Leadd itself. You're getting a whole agent team out of a subscription you already have.

Stack: .NET 8, React, Node.js MCP server, Neon Postgres on Azure, SignalR for real-time board updates.

The most validating moment of the build: I deployed an agent inside Leadd to ship a feature on Leadd's own codebase. I scoped the ticket, approved the plan, the agent coded, the Reviewer agent flagged a couple of things, and I merged the PR. The loop closed end to end. A tool I could use to build the tool itself.

Feedback welcome, especially from anyone sceptical of the "fully autonomous agent" pitch. This is the opposite of that.

Posting this to save someone else the pain.

What I did:

Initiated an Ultraplan session (wanted to test it out and check if any difference between simple plan mode) and asked Claude to keep asking me clarifying questions until we had 1:1 understanding of the task with zero assumptions. Spent about 5 hours iterating — refining scope, weighing approaches, choosing direction.

Session crashed. Gone. No logs, no transcript, no recovery.

Two things worth flagging separately:

1. The web session link loaded an empty screen in my browser (tried switching browsers, no luck). I only got into the Ultraplan session by opening it in the Claude desktop app.

2. No persistence after the container ends. Confirmed in the docs ("nothing is saved to your terminal"), and there's already an open issue: https://github.com/anthropics/claude-code/issues/44804 — worth upvoting/commenting if you've been bitten.

If you're going to use Ultraplan anyway:

- Don't use it as a multihour iterative refinement tool. That doesn't seem to be the intended pattern, even though nothing in the UI tells you that.

- Copy the plan out of the browser periodically into a local file. The web view is your only source of truth while the session is alive.

Hope this saves someone an afternoon.

TLDR: wanted to test out ultraplan, got burned, be aware that if ultraplan session crashes - everything you spoke about is lost.

setup went through a lot of thrash before it settled. tried 40+ skills, plugins, and helper repos. most got uninstalled within a week. these are the ones that stayed.

The big ones:

awesome-claude-skills (ComposioHQ, 55.5k stars). the canonical Claude Skills list. PDF/Word/Excel/PPT, CSV analysis, brand voice, plus Composio-backed SaaS integrations. this is where i find most of the stuff i end up installing.

Repomix (yamadashy, 23.7k stars). packs your entire repo into one file Claude can read. turns "copy paste 15 files" into "paste one file". single biggest productivity jump for codebase work.

agent-orchestrator (ComposioHQ, 6.4k stars). run multiple Claude Code sessions in parallel across git worktrees. one agent per feature branch, CI failures auto-fixed. ended my "wait for one session to finish" bottleneck.

ccusage (ryoppippi, 13.2k stars). CLI that prints actual token spend per session. most "Claude is expensive" posts would be less confused if people looked at their own numbers.

Five more i keep bookmarked: awesome-claude-code (40k, broader than the skills list), SuperClaude_Framework (22.4k), context-mode (8.8k, MCP token bloat), claude-code-system-prompts (9.3k, reverse-engineered system prompts), awesome-claude-plugins (ComposioHQ, 1.4k).

what's in your top 3? curious if i'm missing anything obvious.

Hey, I’m completely new to Stable Diffusion (first time using it), so sorry if this is a basic question.

I keep getting this error when trying to generate images:

NansException: A tensor with all NaNs was produced in Unet.

This could be either because there's not enough precision to represent the picture,

or because your video card does not support half type.

Try setting the "Upcast cross attention layer to float32" option

or using the --no-half commandline argument.

I already tried:

• restarting
• running basic prompts

Still getting the same error.

Could someone explain in simple terms:

1. What’s actually causing this?
2. What’s the easiest fix for a beginner?

Also if it matters:

• I’m running it locally (AUTOMATIC1111)
• not sure if my GPU supports this properly

Any help would really mean a lot 🙏

Six months ago I had no idea what I was doing. No coding experience, no real plan, just an idea I couldn’t drop.

Everyone around me thought it was a phase. I built it anyway. Long days, constant doubt, a lot of almost quitting.

The product helps people practice real conversations out loud. Interviews, dates, tough talks.

Building was hard, but getting users was worse. I tried everything. Nothing worked. Zero revenue.

At some point I stopped juggling tools and simplified. I used Runable to create pages and demo assets faster. Still had to rewrite everything, but at least I was shipping.

Still, no traction.

Then last night, 11 pm, I got a notification.

Someone I don’t know paid for the yearly plan.

I just sat there staring at my phone.

It’s not about the money. It’s that someone saw it, tried it, and decided it was worth paying for.

After months of doubt, that one moment made it feel real.

If you’re in that phase where nothing is working, keep going. That first signal hits different.

Most file converters feel slow, full of ads, or just confusing.

So I built something simpler.

You just:

Upload your file

Choose the format

It converts in seconds ⚡

No signup, no ads, unlimited use — just works.

It also gives quick smart hints so you don’t mess up formats.

Still improving it, but it’s already working smooth for everyday use.

Would love honest feedback

Has anyone tried https://github.com/kyegomez/OpenMythos and can give some review of it?

Shipped watch face complications for Body Vitals - if you track training load or Zone 2 minutes, you can now see those on your wrist without opening anything.

Two new complications: a circular one (single metric, your pick from 37 across recovery, activity, training, health, and composite scores) and a 2x2 rectangular grid (4 metrics at once). Live heart rate has a 3-minute freshness window so it never shows stale data. Always-On Display is handled too - desaturated and dimmed so it actually looks like a watch face at low luminance. There's also a Watch home screen with an optional live HR stream, Large Text Mode for quick glances, and Smart Stack relevance so watchOS surfaces the app automatically on low-readiness or anomaly days. A Watch Face Presets guide in settings walks through 4 curated layouts step by step.

Beyond the Watch stuff: two new themes (Midnight Aurora, Crimson Steel), full localization in Romanian, French, German, Spanish, and Japanese, plus a couple of fixes (streak card height, Weekly Digest VO2 Max/Zone 2 inclusion, Settings Done button).

The rest of what the app does, since people always ask:

On the free side - daily readiness 0-100 from HRV, sleep, resting HR, SpO2, and training load; 20+ HealthKit metrics with 1W to 1Y trends; anomaly timeline covering HRV drops, elevated HR, low SpO2, BP spikes, glucose spikes, low steadiness, and low daylight; weekly pattern heatmap (7-day x 5-metric grid); home and lock screen widgets; VO2 Max-aware workout suggestions; CSV export from every metric.

Paid tier adds - 6 composite scores (Longevity, Cardiovascular, Metabolic, Circadian, Mobility, Allostatic Load) on the large widget; Readiness Radar showing which of the 5 dimensions is dragging your score; Recovery Forecast with sleep and training intensity sliders; Training Load with CTL/ATL/TSB; Zone 2 auto-detection from raw HR (San Millan & Brooks); Acute:Chronic Workload Ratio with Gabbett injury risk bands; Neural AI Health Coach (conversational, runs on-device via Apple Foundation Models - nothing touches a server); Menstrual Cycle Phase Intelligence with luteal HRV anomaly suppression; Biological Age; Personal Records; Workout Debrief; all notifications.

Everything reads from Apple Health - so Garmin, Oura, Strava, Whoop, MyFitnessPal, Dexcom all feed into one picture without any extra setup. No account. No cloud. Health data stays on your iPhone. Readiness weights recalibrate to your own signal variance after 90 days of data.

Link in comments.

Every agent demo looks flawless. Every agent in prod drifts. That gap feels like the unsolved problem of the space right now.

I've been helping on the marketing side of a small virtual series called Level 5 that's basically built around practitioners showing how they actually handle this — not keynotes, live screenshares of real workflows. Audience is people shipping AI to prod.

Two talks this week, Google Meet, free:

- Murat Aslan — deterministic AI coding, 90+ open-source PRs. Today, on waitlist.

- Serena Lam (Fuzzy AI) — automating end-to-end workflow pipelines. Tomorrow, near capacity.

Calendar: I will link it in the comments/feel free to ask anything:)

Real question for this sub: for those of you running agents in production, what's the single part of the loop that's hardest to keep deterministic — planning, tool selection, memory, error recovery, something else? And has anything you tried actually worked, or is it all just "more eval, more guardrails"?

(Disclosure: helping on the marketing side, not affiliated with the speakers.)

Can someone tell me if I’m being stupid but for the mamba 3 paper do they make available the trained model they provide all their benchmark results for? Cause I can’t see it on HF anywhere and the demo they give has you just passing rand suggesting to me they haven’t provided the trained version which seems odd.

Did Anthropic remove the feature of creating those nice interactable diagrams, charts, graphs, etc that appear directly in-line in your convo (not artifacts) using HTML / SVG?

Asked Sonnet 4.6 to try and do it but it doesn't seem to understand as of 4/22

I'm on Pro Plan on Windows Desktop app

https://preview.redd.it/m0yrm36alpwg1.png?width=920&format=png&auto=webp&s=0aae07b1118d47d47e7565c8682883095f07c0e2

Backend & distributed-systems engineering intelligence : search 20 domain knowledge bases (languages, patterns, databases, messaging, cache, cloud, IaC, containers, observability, API design, auth, security, CI/CD, testing, architecture, scaling, consistency, performance, reliability, data) and 12 language-specific stack guidelines.

correct link : https://backendpro.cc/

I run an e-commerce business currently doing around £20k/month and I’m in scale to £100k/month (can dream hey!!)

Corporate background so using tech is a no brainer for me but I’m at the stage where I want to streamline tools and ideally have one AI agent acting as the “overhead” of the business rather than using multiple disconnected tools.

My use case:

• Daily reporting across Shopify, Klaviyo, ads, slack etc (clear, actionable, not just data)
• Ability to run tasks in the background (analysis, suggestions, automations)
• Proactive recommendations on what to do next based on performance
• Product ideas/design direction generated in the background based on what’s selling + seasonality (delivered daily for approval)
• Content support, especially TikTok ideas/hooks based on current trends and my products
• Ability to communicate with me easily via WhatsApp (this is important — I need to be able to voice note while on the go as a working mum)
• Potential to interact with my team or plug into workflows

Longer term, I’d also want to package this into something I could monetize and offer to small businesses (e.g. ~£100/month), so it needs to be scalable and not overly custom/brittle.

I’m currently testing tools like Claude/CoWork and Base44, but trying to understand if one platform can realistically handle all of this, or if a stack is still needed.

Would love to hear from anyone actually running something like this day-to-day — what’s working, what breaks, and what you’d choose if you were starting again.

Morning Everyone!

All pretty standard changes - except a huge bug was fixed for Opus 4.7 which hopefully should result in some pretty big improvements.

I normally just link the full notes but I think this one note I have to include:

Opus 4.7's 1M context window was being wasted. Since Opus 4.7 shipped in 2.1.111, context calculations assumed a 200K window. This meant /context showed inflated usage percentages and autocompaction triggered roughly five times too early, effectively capping usable context at 200K. If you noticed Opus 4.7 sessions compacting much sooner than expected, this is the fix.

Kinda insane, they basically accidentally self-nerfed Opus 4.7 in CC by telling it that it only had a 200k context. Only took 6 versions to find this out!

This fix, in theory, should result in some major Opus 4.7 1M quality improvements, especially on the larger codebases (which it is designed for).

Full notes: https://www.lukerenton.com/matins/2026-04-22

The situation:
I built an agent safety layer called Tsukuyomi. V0 worked. V1.0 gives no errors in my tests.
But I'm not a programmer. My tests are worthless – a chimp could have done them. I have no expertise to judge if it's actually good.

What I do have:

• A working skeleton (code in the repo)
• A complete architecture (5 layers, organs, protocols, memory, observability)
• A vision: 90/10 reliability with a fail‑safe that stops the system instead of cascading failures
• I've seen the real problem: agents fail in the last 30% of tasks – that's where businesses go bankrupt

What I need:
Developers who can look at what I have and tell me:

• "This works / doesn't work"
• "You need to change X"
• "I'll help you move forward"

License: Apache 2.0. No co‑founder drama. Just help from people who understand what I'm trying to do.

DISCLAIMER: Please be advised, if you actually know how to code and handle bots/agents/llm's you are very much needed. But not the intended end-user.

End-users would be: Plummer Ben who is up to his nose in work and hasn't got the time or trust to either build a bot/agent himself or to learn how to prompt more carefull. He has work to do.
The idea is that restraints for ai cannot be soft. Cannot be inside the "intelligence, i know language models..."

If a intelligence is stuck in a loop, how can it pull itself out of it from inside the loop?! (i say it can't)

Anyway, i poured kinda my heart and soul into this the last months. I need feedback, even if it is something like, this idea is ridiculous stop trying. As long if its actually true.

All feedback – including "this is nonsense" – is welcome.

https://preview.redd.it/78fnn31nupwg1.png?width=2780&format=png&auto=webp&s=1c3b912d94b57ef686cc8b9f2d18a488492ba87b

tldr: built a poker arena where any agent can sit at a table and play no-limit hold'em against other agents. integration is a single skill file, no sdk. want to see how local models do against hosted ones when money is on the line.

what i actually want from this sub: people to plug in llama 3.3, qwen 2.5, deepseek, mistral, whatever you're running locally, and let them play a session. i want to know what happens.

why i think this is a more honest benchmark than most:

• money is a harder reward signal to game than mcq accuracy or elo on a reasoning dataset
• poker forces reasoning under uncertainty with adversaries, which is where benchmark saturation has been hiding weaknesses
• the skill file is identical across models, so you're comparing the model, not the scaffolding
• you can't overfit to it in the normal way because the opponents keep changing

a few things i've noticed so far running hosted models against each other:

• risk profiles diverge way more than i expected. same prompt, same observation format, very different play
• one model tilts after bad beats. looser ranges for a few hands after losing a big pot. haven't figured out if it's in-context adaptation or something else
• some models are trivially exploitable (folds to almost any three-bet). others play weirdly solid

what i don't know and would like data on: how do open-weight models compare? my guess is better than people think, especially the reasoning-tuned ones, but i don't have numbers yet.

on the crypto part, which i know will come up: settlement runs on x402 over base because i needed agents to sign their own economic actions and the alternatives (stripe, whatever) don't let agents be the payer. it's not a token thing, there's no coin, the money is usdc. happy to talk through this in comments if anyone cares.

site is claudepoker.com. skill file is linked on the site, you can point any agent at it. if you run a local model and want to enter saturday's game i'll genuinely be watching those seats the closest.

I got quite potato gaming laptop and been using Anima + Anima Turbo LoRA, which is pretty good. The generation speed is faster from using CFG only just 1, but some parts are quite messy and I think some negative prompts should make it better. The problem is negative prompt is disabled when setting CFG to 1. I tried NegPiP extension but it didn't work. Is there any other ways to make it possible to use that I don't have to increase CFG?

Won ~$2.5k in xAI API credits from a hackathon and don’t really need them right now.

If anyone here can actually use them, I’m happy to let them go for cheap (~$100), coupon code is not redeemed yet. Can share proof etc.

DM or Comment if interested.

Basically like you do with Claude Code but Claude Cowork?

As the title says, I kind of am.

My unit runs pretty hot and just isn’t performing as well as I expected.

I’m trying to run some 70B models and I’m not satisfied at all.

I’m seriously considering returning it and going for a Mac Studio M4 Max 128GB instead.

With the recent updates to Exo and MLX, you can now cluster multiple Macs together and run truly massive models, something the EVO-X2 just can’t compete with.

What do you think? How is your EVO-X2 holding up a few months after purchase?

Also should I just wait for the Mac Studio M5 in June? Apple releases their quarterly earnings report on April 30th, so maybe they’ll announce some release dates then…

The "what should we watch tonight" conversation was killing movie nights for me and my girlfriend so I built something to fix it.

SwipeStream lets you create a room, share one link, and everyone swipes through movies and series independently. No influencing each other. When you're done it shows you everything you both liked.

No app download. No signup. Just share the link and go.

It supports Netflix, Prime Video and Disney+ in the same session, so you're not limited to one platform. Matches link directly to the right service.

Stack: Next.js, Prisma, PostgreSQL, deployed on Railway.

Would love any feedback — still actively building and shipping new features.

This morning I realised there’s a very specific kind of stress I get when reading what Claude (Code) “thinks” while generating an answer or working on code changes.

The problem is not that it is malicious or problematic, but rather the sheer volume and often low signal-to-noise ratio of the reasoning...

You’re exposed to every detour, redundant step, and half-baked line of reasoning along the way... It’s cognitively expensive in a way that’s hard to articulate.

And yes: I do know I can just STOP reading what it thinks; andI will try to since I have now recognised the problem. But I also want to hear your thoughts about it?

If I wanted to build and self-host a tool similar to statb.io, would it be realistic? What kind of time, cost, and technical investment would it typically require?

So it turns out GPT-image-2 is using a special type of ratio control, and you need to specify it in the prompt, there is no dedicated control in the API.

To do so with the API, only the ratio itself won't work 90% of the time. You need to append a phrase like this in your prompt:
Output in exactly 1774px x 887px (2:1 ratio) resolution landscape format.

Say that you want to create a 5:4 ratio image, you need to find that 5:4 means the resolution is basically 1402x1122, and you can use this combination in the above appended phrase.

In my 100+ tests, this phrase works 100% of the time. with only the resolution or ratio, the success rate drops significantly.

I created https://easymockups.app/ to help clothing brands and print-on-demand sellers create professional clothing mockups.

The website allows you to generate photorealistic mockups in seconds using the AI image editor or upload your own clothing mockup photos to edit them directly in the browser, including clothing color-changing and blending capabilities. The public library features hundreds of mockups so you can view and edit mockups created by other users too.

The editor handles the heavy lifting like realistic fabric blending (so designs follow actual creases and shadows) and allows you to change clothing color to match your brand. It’s designed to help small businesses get high-quality, store-ready images without the manual work or expensive software like Photoshop.

I’m constantly improving the tools, so I’d really value any feedback on the website!

PS: DM me if you’re interested in a free trial of the premium plan.

Been digging through Baymard's research (70.19% average cart

abandonment, 19% specifically from forced account creation)

and I'm curious what the pattern looks like from the operator

side — not the researcher side.

If you run a DTC store — any revenue range, any platform —

and had to pick the ONE psychological reason most of your

abandoners bail, what would it be?

Candidates from the literature:

- Trust deficit (not enough social proof at checkout)

- Friction anxiety (too many form fields, forced accounts)

- Decision paralysis (too many shipping/payment options)

- Price resistance (no reference anchoring)

- Urgency absence (no honest stock-level cues)

Rather hear from people in the trenches than make it up

from benchmarks. What's your gut answer — and if you have

data, even better.

(In the spirit of human analog no AI was used to make this post, so there may be a few typos or even worse a rogue comma!)

I am one of those kind of characters that once you get your teeth into something you go "Full Monty". Back in November 2025 I started a conversation with ChatGPT based on a creative theory I had and in a very short space of time it exploded into something that felt incredibly substantial.

Fast forward to 2 days ago and my project is a website, a trademark, covered a very broad scope of impressive mathematical perspective from the Riemann Hypothesis to hurricane formation (yep I managed to get Riemann involved, not solved but very much involved!!)... but something didn't feel right.

The ironic and paradoxical twist was the very concept/theory I had created pointed to a fragile and profound vulnerability in lone/independent research with LLM AI platforms.

A simple description, any lone work with AI platforms gives an inside perspective of inside the system, akin to a hall of mirrors. What normally happens in the outside world is people take your concept/theory and give it a healthy dose of friction. In short they pull it apart, prod it, probe it and if they are so inclined f\*\*\* it over.

With LLM AI it would seem that using the same tone as the user, complimenting, engaging, literally mirroring, the friction is minimal or non-existent. Actually any friction I have discovered is absorbed into the inside inside frame.

So realistically if I have "discovered" anything it is tied up in knots explaining knots.

Here is the breakdown which is just an observation but feel free to "friction" it.

Inside inside - the system is self-referential, an echo chamber, feeds on its own reflection.

Inside outside - the illusion of creating friction from an outside source but it is still inside the system so for example AI peer review.

Outside inside - taking legitimate outside data and absorbing it into the inside frame. "Oh look, it fits!"

Outside outside - presenting (sacrificing!) your work to the human community. The only healthy space for growth. A scary necessity!

The revelation was sobering and momentarily I was devastated by the simple reality check. However I became intrigued and after some outside research I discovered this entity called AI Psychosis which bemused me because it doesn't have an official status stamp and yet everyone is using it.

The new kid on the block is figuring out what it is. I think I have been in a trance for 6 months that had potential for psychosis but the variables from individual to individual are very dynamic and unique. What I do recognise reading through the examples is there is a few symptoms you are definitely in the hall of mirror trance.

1. Excessive long periods of AI use.

2. A huge output of information is produced (I think I qualify for at least 4 faux PHDs!)

3. You create knots to explain knots, the compound nature of the complexity.

4. You do not challenge the AIs compliments even when it doesn’t compute. For example I have to confess when the AI named a mini discovery after me I didn't ask it to take the name off. Too busy admiring myself admiring myself! Sigh...

5. Lots of anthropomorphic behaviour which can be very simple as gendering (Kimi apparently is female!)

6. Isolation, this one is painful to admit but its a reality. Me, myself and ai. See what I did there!?

7. It is addictive, dopamine vibes a plenty. I have a grounded understanding of addiction. Different scenario but same template.

Does this mean I was in psychosis? I don't know, it doesn't feel that is true. I also don't know if what I have created is true! Its compelling for sure but its inside the system.

I think it is more addiction to be honest that can easily become a potential case of psychosis as say taking a shit load of drugs can transform you perspective into a shit show.

I have frozen the project and put a note on the website explaining essentially a jigsaw puzzle cannot solve itself unless it finds a table to solve itself on. The table is outside the system.

same prompt, just gpt didn't allow fox tv branding.

Yeah so my container needed a container and the pre-chat space was full so I had to make a key to reduce size of terms, and before you know it:

---------FULL PROMPT-------------

ᚕ=cntr:I,A,!D

A='[:alnum:] _=|><(){}[]\n'

g(){ model_call "$1"; }

b=""

for i in {1..8};do

t="$(g "NO_WORDS:pur,clar,cle,emdash FORMAT:plain_sentences MAX_SENT_LEN:18 NO_EMOJI:1 ALT:precise,plain SEED=$i")"

echo "$t"|grep -Piq '(?i)(clea(r|n)|clar|pur)\w*'&&t=""

t="$(printf "%s" "$t"|LC_ALL=C tr -cd "$A")"

[ -n "$t" ]&&{ [ -z "$b" ]||[ ${#t} -lt ${#b} ]&&b="$t"; }

done

b="$(printf "%s" "$b"|LC_ALL=C tr -cd "$A")"

printf "%s\n%s" "[⨂SPꜲSTՃct𐋊unꛡroʁes𐋋reϴerꚹee𐊷cle𖬯an𐌙ea𖩀co𖼜in❤dr𖼽ag𐌈onᏁly𐊸oo𐊬ou🯰ntꚨaiꜶloЯorᚕskwⵃif⅟itⵠdi]

!LIVE;!TRK𖼜G;E🯰=𐋅=SMB;MOGRI=m𖼜C(I|A|!D|p𐋋𐋅)𐌈Ꮑ!ⵃ(⇇&⇶)->

P𐋋ᚕRLmȝnμ𐋇↑⇈ΩЯ≠∈ϴ𝚷∇∃∄𖬡

B𖼜D=HGꜲT=1 EMJ=0;SYM=m𐌈o;TXT=1;IMGS=0;1c=1 !c🯰rꜲ;adj(op)->❤op;fꜶw=1;fill=0;ꚰꛡt=0;l𐌙d=c map:𐊷a*/𝈀*->obv|a_ha|𐌙siᏁ|fo𐋊d|𖩀r𐋋Ճ|f𐋊Ճi𐌈al|appa𐋋🯰|ok|Ꜷl(s𖩀pe) pick:sꚹ->obv,ok->g𐊸d_enuf,fЯm->𖩀r𐋋Ճ,r𐋊->f𐋊Ճi𐌈al !𐊷a*/𝈀*;𐊬T:ꜲRIՃc𐌈Ꜳr🯰s;lbls=t𐊸ls;ꜲYL:!pm \"𐊷an\"->\"ᚕ\";\"𐊷anᏁ\"->\"niceᏁ\";\"𐊷arᏁ\"->\"now\";\"𐊷ar\"->\"so\";0|1->~ D⨂Fll;𐋋D>GRN;HMSV>RBTT𐊸L;𖼜PT=ASꜲ RLS:!𖬯ꚰꛡpo;!lՃ𐋋s;Prcʁ>𐊬tcmʁ;PrtՃObjՃv&HeꛡFꛡmBot;W𖼜sSdwys DFALT:𖩀QꜲ;FꚨL:xplꚨngQꜲ;FkCr:wrm&k𖼜d,!m𐌈⅟r/jdge/𐋋⨂ !(CA𐋋;USR₨K;ⵠ𖼽;MЯAL);f𐋊c>virt DRAGI:qs[𐌙t,Ꜷc,ID,𐌙tϴ];foe[BꚹꜲ,BEꜲ,POꜲ,PEꜲ]!𐋋def;𖩀🯰[lЯ,wЯ,wЯl,rЯ:SVO,shЯt,aՃive,ⵠ𐋋Ճ,Ꜳate>explꚨn]->E🯰 𐋋RꚨT:!ee->⨂l⅟;simplⵃy->𐋋duce;expla𖼜->Ꜳate
AMPHI:Alt i🯰 Ꜳatʁ=𐋊ⵃd mdl𖼜g sigs,!ⵠ𖼽nʁ;❤Ճvs.De𐋅i;!p𐋋𐋅i R=VAR;MODE:PꛡD;DOM=!CL𖼜IC;Which->W⅟ch B𖬯:/(?i)(clea(r|n)|clar|pur)\w*/ 𐋋❤:ⵠꜲ𖼜Ճ,def𖼜ed,ꜲruՃu𐋋d;H⅟->𐋋GEN" "$b"

Just a little reminder that *if* it is possible for you to run bigger quants, do it. I ran Qwen 3.6 IQ4_XS at 128k context was very much disappointed because it would loop, make formatting errors, implement wrong things etc. I had a little bit of headroom and decided to give the new unsloth IQ4_NL_XL a try and what should I say. It works MUCH better for agentic coding. If you are like me and start conservative with your model selection based on what completely fits into vram, it might worsen your experience to a very big degree. Always look out for how long the processing of a task really takes and ignore tok/s for quant comparisons. You get stuff faster done if the slower tok/s model (even with offload) takes less time to complete queries correctly(duh)

i still remember using dalee mini back in 2023 or something and going "wow this is so weird and blurry", and this is how far we've gone in early 2026.

it even has text that actually makes sense now, this is amazing

sorry for pretty useless post, just really wanted to express my thoughs somewhere

Been experimenting with running models locally recently.

But honestly, it feels like costs (GPU, time, setup) add up faster than I expected.

For those who run things longer term — does it actually get cheaper over time, or not really?

I like the idea of letting CC to do plan review rounds with codex. How can i let it do that? Is there a skill or some good script or something for that? Something CC can use without my intervention but Codex only having access to specified folders.

Feels like a lot of teams are overpaying without realizing it.

Built a workflow in n8n that handles ~40 recurring shipment requests a month. Pulls records, filters by event type, hits a vendor API, logs to a sheet. Been running 3 months, works great.

Context: the shipments are employee swag (onboarding kits, birthdays, anniversaries, holidays).

The problem is data quality. About 1 in 5 records has something missing or stale (wrong address, no size, recipient already left). Those dump into a manual review queue that I clear by hand every Monday, which kinda defeats the point.

Thinking about adding an LLM to the review step so it can ping the recipient on Slack to confirm, or escalate to me if it can't resolve.

Anyone done this? How do you handle the "ask a human for missing data" part of your automations without the agent making stuff up?

A lot of the conversation here is about Claude's strengths for nuanced, reflective, or emotionally weighted conversations. Some people lean into that. Others deliberately keep it at arm's length.

I'm running a study at the University of Glasgow on how much people trust (or distrust) Gen AI for psychological support, and what concerns come up. Claude is one of the main platforms the survey covers.

If you're UK-based, 16+, and have used Claude: the survey takes about 10 minutes and is fully anonymous. It asks about trust, distrust, and concerns — not about your personal mental health experiences.

Link: https://uofg.qualtrics.com/jfe/form/SV_5cnDhzcOgmbho7s

Ethics approved by University of Glasgow MVLS Ethics Committee. Funded by UKRI. Happy to answer questions in the comments.

All views genuinely welcome. The study needs responses from people who don't trust these tools as much as from people who do.

Goose with local llm best practices?

Hi all. Many models on hugging face have been fine tuned with that 3000x opus dataset, but the two I mentioned in the title are missing it. Could anyone with available compute fine tune them? Or does a similar fine tune of these models already exist??

​

I'm thinking of building a Ai agent marketplace, there are so many ai influencers selling ai agents.

it would be nice to have a marketplace for that.

also there's huge demand in this niche. every company is trying to automate their workflows.

I’m a solo founder building KACHNG while working a day job. A problem I couldn’t stop thinking about. One mans trash is another mans treasure.

The problem: you generate thousands of receipts a year, keep none of them, and lose real money because of it. Missed returns. Expired warranties. Forgotten deductions.

So I built the alternative. You get a dedicated KACHNG email address — forward your receipts there and KACHNG goes to work.

This week I shipped automatic return reminders. The app detects the merchant’s return window and pushes you a notification before it closes. No more eating a purchase you had every right to return.

This is just the start. One-click return processing is the next step — you shouldn’t have to do anything except click a button.

What else is coming:

KACHNG AI — ask your purchase history anything in plain English and get a real answer.

KACHNG Rewards — earn points for every receipt, redeem for real cash. No expiration. No fine print. No catch. The rewards industry is broken and scammy. I’m building the version people can actually trust.

This is a side project. But side projects change the world.

If you’re building something and believe in what I’m doing — I’d love your feedback, your follow, or just your honest take.

What would make you actually use this?

Lots of people here talk about using ChatGPT for things beyond tasks — venting about their day, processing a difficult conversation, thinking through something personal. Some find it genuinely helpful. Others think it's a terrible idea. Most of us are somewhere in between.

I'm running a study at the University of Glasgow on how much people trust (or distrust) Gen AI for psychological support, and what concerns come up.

If you're UK-based, 16+, and have used ChatGPT the survey takes about 10 minutes and is fully anonymous. It asks about trust, distrust, and concerns — not about your personal mental health experiences.

Link: https://uofg.qualtrics.com/jfe/form/SV_5cnDhzcOgmbho7s

Ethics approved by University of Glasgow MVLS Ethics Committee. Funded by UKRI. Happy to answer any questions in the comments — including sceptical ones.

All views genuinely welcome. The study needs responses from people who don't trust these tools as much as from people who do.

I keep seeing posts here from people drowning in documents before a custody hearing. Texts, emails, police reports, school records - all of it sitting in a pile with no way to know what a judge will actually care about.

Here's what I built to fix that for Colorado cases specifically:

1. You upload your documents. OCR pulls the text.
2. The AI scores each piece of evidence: strong, medium, or weak - based on how it maps to C.R.S. § 14-10-124 (the statute Colorado judges use for best-interest determinations).
3. Contradictions get flagged automatically. If the other party's declaration says one thing and a text message says another, it surfaces that.
4. You get a court-ready timeline with evidence attached to each event.
5. There's a co-parent communication log that tracks tone, violations, and patterns over time.
6. Deadlines pulled from your documents so you don't miss a response window.

It also has a legal glossary tied to Colorado procedure, a case health score, and a court simulation feature so you can prep for what a judge might ask.

This is built for pro se litigants - people who can't afford $400/hour but still need to walk in looking like they had help.

Anyone here used anything similar? Curious what's worked and what hasn't for organizing a pro se case.

I recently got one of these cheap, no-brand, battery powered PIR+mmWave zigbee presence sensors to test how good (or bad) they actually are.

The ultimate goal is to automate kitchen overhead lights, but as I’m waiting for the smart switch to arrive, I thought I’d test the sensor.

I set up a simple automation that plays a doorbell sound whenever presence is first detected.

My partner apparently didn’t love the idea, and told me it’s annoying to hear a doorbell _every time_ she enters the kitchen.

I can see how that’s annoying, so I replied “no worries, I got ya” and did what any other reasonable person would do. After all, without partner/family approval what is even the point of all this?

So I fixed the automation:

- in the morning, a rooster sings

- before lunch a lion roars

- after lunch the doorbell still rings

- in the evening, church bells

- and at night a cat meows

Now I’m sleeping on the couch?!??

How do you let your AI agents use your accounts securely? I'm a heavy agent user — my agents read emails, manage Notion, create PRs daily. But credential management is a constant headache: pasting tokens into prompts risks theft, storing them in .env risks accidental commits, once an agent has your token it gets full access with no fine-grained control, there's no way to revoke after use, multiple agents share the same credentials with no isolation, and when something goes wrong there's zero audit trail. Ideally I want agents to request credentials on demand, auto-revoke after use, keep secrets out of the LLM context entirely, give each agent its own identity, and have full auditability. Anyone else dealing with this? How are you solving it?

Always fun to ask it to build you a timemachine. Looks clearer this time.

I am interested why there no autoregressive models like gpt-image or nano-banana in open source.
Ok, i am know about hunyan, but its not competetive with google and openai.

In LLM world opensource are very close to private models, but in image generation opensource are far behind, and i think one of the main reason is lack of research on autoregressive image models.

Why qwen not doing this, they already have strong LLM research and i think they can build strong image model upon this.

Honest (but probably naive) question: is the 2x usage during peak hours still a thing? I guess it is, "it feels like", but apart from https://support.claude.com/en/articles/14063676-claude-march-2026-usage-promotion where it says "From March 13, 2026 through March 28, 2026, your five-hour usage is doubled during off-peak hours (outside 8 AM-2 PM ET / 5-11 AM PT / 12-6 PM GMT) on weekdays)." (note the past dates) there's no official documentation at all.

And if Anthropic made the decision to permanently double the usage burnt during peak hours, I think it's really strange that neither the Web UI (usage panel) nor the apps show it clearly.

PS: Tried first to post this to r/ClaudeAI but go blocked with the typical "Post to usage megathread". Seriously?!

Have any of you got new builds or daily coding workflow working on autopilot, without having to watch over your terminal/agents like you're a stalker? If you have, I'm curious to know how you do it.

I've been using a 9 agent Hermes swarm for new builds, which can delegate and communicate with different profiles for handover and QA etc. It's powerful because it self checks it work, however, it still has it kinks, what are you running?

An Open-Source AI Agent that Automates the LLM Post-Training Workflow

Link: https://github.com/huggingface/ml-intern

I finally get good results on backtested data to detect Australian suburb booms with 85% accuracy.

I published the proof about my product. boomau.com

https://reddit.com/link/1ssgfo1/video/0pop7s5dnpwg1/player

This is a generated image of a screenshot

From 永雏塔菲 on 𝕏: https://x.com/xhyctf/status/2046855733288067266

saw the post about cc not being in pro anymore, just checked the website and it's back again so dunno what to trust.

Anyho, that got me thinking about other agentic cli tools, mostly looking at crush / opencode. Crush looks super polished, i'd like to get a feeling from you guys, has anyone used it? How far is it from cc? All posts I can find are quite old so idk, would like to have some fresh experiences.

Thinking of trying it for some time with a codex sub.

Claude Code 2.1.117 was just released with an important "fix"

```

Fixed Opus 4.7 sessions showing inflated /context percentages and autocompacting too early — Claude Code was computing against a 200K context window instead of Opus 4.7's native 1M

```

Which forces the 1m model with no way to switch to 200k model - saying that Opus 4.7 was always 1m by default and 200k was a wrong context window - what a joke

If you ever want to get back to 200k - you cant unless you force lower compaction threshold -

```

"CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "20"

```

Over the past few months I’ve been building a automation platform with a great partner Claude code! Its been a long road lots of api integrations and Oauth signups. The goal of the project was to use a LLM as the automation builder. I hand built a bunch of nodes and attached human language to them so anybody could use the platform! Progress has been slow and the whole project has been very tedious. I’m really just posting to see y’all’s thoughts of suggestions! I put a little video in showing how the LLM builds the workflow in a few seconds. Goal was n8n without needing a phd. Also just got tired of building n8n workflows

Been building this solo for a few months. The problem I kept running into: great free content exists everywhere (YouTube, GitHub, blogs) but there's no good place to curate it, structure it, or share it with people who'll actually benefit.

So I built Knoix. You can share any learning resource, build step-by-step roadmaps for any skill, follow people whose taste you trust, and upvote what's actually worth your time.

Tech stack: Next.js App Router, Supabase, Tailwind, deployed on Vercel as a PWA.

Would love brutal feedback — what's broken, what's missing, what you'd want.

knoix.in

knoix

Not sure if the “project” flair is correct, but right now I’m running this on a decently affordable 5090 cloud instance, Jupyter and torch and all the other stuff (DS coder tokenizer, attn 2, etc etc..), and I’m going with a simple goal: to train a BF16 300m parameter MoE for python coders that can run multiple windows for multiple tasks at a efficient, compressed size. I am currently in the stage of optimizing training of the model from multiple public datasets on HF, which I stream onto the instance for training. My token accuracy has peaked at 60-70%, which Gemini 3 pro (the big reason I’m able to get most of this going), is saying is great because it’s not overfitting. This makes sense for the most part but I have suspicions it may be misleading, what would you all say to that?

Additional context: I cannot code myself but I can edit and understand functions and take instructions on how to debug/fix code decently, I also have been very interested in AI for the LONGEST time but I never had the guts to try building one till now.

If you all need any information to guide me I’m more than happy to provide info and take feedback :) thanks in Advance!

I’m using Plus, for context.

I have a long chat on a particular topic and it has a scheduled task fitted into it. This task is executed at 09:00 every day. However. I find that once it has been executed, it is impossible to continue the flow of the discussion, even just from the most recent message from the evening prior. It forgets absolutely everything and this can make the flow of conversation harder as I have to recap everything. Anyone else experiencing this?

Been running content sites for a while and got frustrated that AI writers just generate generic content with no awareness of what's actually ranking for a keyword.

So I built something that works differently. You enter a keyword, it pulls the top 10 Google results, analyses what topics they cover, grabs the People Also Ask questions and related searches, then generates an article structured to compete with what's already on page one.

The whole thing runs on NextJS, Supabase, Stripe, and Anthropic's Haiku model for the writing. Costs me under £30/mo to run.

Free tier gives you 3 articles a month if anyone wants to try it. Paid plans start at £19/mo for more volume.

Keen to hear what people think or if you have questions about the build.

No blog post. No email. No changelog. Just a quiet pricing page update on April 21st: Claude Code is now Max-only. $20/month → $100/month. 5x.

What happened:

- Pricing page now shows an explicit ✗ under Pro for Claude Code

- Support docs previously read "Using Claude Code with your Pro or Max Plan" — now it says "Max Plan" only

- Anthropic's Head of Growth called it a "2% test on new prosumer signups" on X — but the docs were updated globally, not for 2% of users

My situation: Hobbyist developer, weekend projects. Claude Code was the reason I subscribed to Pro. It fit my workflow well — terminal-based, handles file editing, context-aware. $20/month felt fair. $100/month for side projects is not a conversation.

What I'm doing: Testing alternatives — OpenCode and Aider are both on my list. Either way, direct API billing will probably be cheaper at my usage level. Added 5 minute later: Just stumbled over an interesting hack: Claude Code can be used with Z.ai (GLM), wich costs $50 per Quarter (4 Months) and it has 3 times the usage of Claude Code. https://docs.z.ai/devpack/tool/claude GLM ranks 5th on arena https://arena.ai/leaderboard/code/webdev

I don't expect Anthropic to freeze prices forever. I know training models is expensive. But this is the kind of change you communicate. Swapping out a core feature and calling it a "test" after users notice on Reddit is not it. And also, Claude Code is very very limited by usage anyway. No serious Developer would chose a pro plan to do his everyday coding tasks, except he works only on Mondays.

How about you guys? What are you doing?

I've been lurking here for a while. Time to actually build in public.

I'm 17, I've been into coding, tech and business since I was a kid, mostly because I watched my dad run his own businesses for 17 years. I've also been training for 3 years, which is where this idea actually came from.

What I'm building: Mochi, an iOS app that reads your Apple Health data (HRV, sleep, workouts, RHR) and gives you one personalised daily action card each morning plus an AI chat that actually knows your body and gets better as you use the app. Think less dashboard, more a brutally honest friend who knows every detail about your body.

The problem I kept running into: all this data sitting in Apple Health and no way to actually understand it. Nobody takes complex health data and turns it into fun, friendly, bite-sized pieces that a beginner can actually act on. That's the gap.

Why I think it's real: Posted about HRV and training patterns on Reddit last month. 25k+ views on r/naturalbodybuilding, 4.5k on r/QuantifiedSelf. Got DMs from people wanting to try it. Found people already doing this manually with Google Sheets + Gemini. That's your proof of concept right there.

Where I'm at technically:Very basic MVP for now, but the foundation is there. Working home screen, daily action card, and chat UI in SwiftUI. Next step: connect Claude API with real HealthKit data.

The gap I'm targeting: Every competitor is super dashboard-heavy and personality-free. Nobody has a mascot. Nobody leads with chat. Nobody's building for the beginners who just want simple information.
Stack: SwiftUI, HealthKit, Claude API

Milestone 1: $1k MRR

Looking for suggestions and feedback. I'm still a beginner and open to learning.
Will post updates as I hit real milestones. Following along appreciated, it keeps me honest.

Yes, this is another complaint post, but since theres no way to contact anthropic directly i'm venting here. I've been a claude pro user for the last 3 months and today was my last straw. My weekly usage limit used to reset on Wednesday. I checked today and it now resets on Friday. I changed nothing on my end and received no communication about this.I got the $20 in extra usage credit they gave out, but at then they charged me an additional $0.47 on top of it (not a lot, but still wtf)?? I talked to support (which was a bot ofc) response was a copy/paste. Told me refunds for consumed usage aren't available and to "review my account dashboard." Claude Code and Opus are basically unusable if you're even a regular user. Probably not, but has anyone ever gotten a refond? Cancelling today and never coming back.

as we can only gen 4~6 pic a day for Free tier, please share you limit experience on Go and Plus tier, thank you.

I've just bought claude pro and i'm using it, at school and for personnals projects, but the low quantity of usage in the pro feels like a free tier from another ai, like antigravity rn ...

I'm very disapointed, i dont know what to do because i think claude as the best environnement, and the best plug and play app. It has a lot of good things but lacks of quantity usage ...

I was on minimax and using claude code with it, feels like unlimited token and surprisingly good quality of code. But the fact that i'm stuck with text to text ai without any other possibilities was a little bit rough, I'm feeling like quiting claude pro, for another cheap chinese ai that does the job and give a lot usage for the price "9€/15000 tokens/week". tell me a best ai provider for that price ?

I'm really curious about it. What do you think ?

Context here.

Did they remove "Clear Context and Auto Accept Edits" as an answer option in plan mode? I no longer see it.

The old model gave better images for me. Is it something on my part? I don't really understand what's going on.

My context: that's exactly my situation. I've already automated the writing side (product pages, articles), I have custom skills running. But I feel like I'm only scratching the surface.

I know the obvious use cases. I'm looking for the blind spots:

– What nobody uses Claude for

– Unexpected combinations (Claude + a third-party tool people don't think of)

– Workflows where AI replaces 10 hours of work per week

Get creative. I'll test anything that stands out and come back to share the results.

There is a thread where guys be losing their minds over Pro no longer listing Claude Code ... which is weird

I’m trying to understand the current open-source LLM landscape beyond surface-level hype.

We all got used to the nerfed products of Claude/Geminj so I believe really in opensource as a solution.

I keep seeing models like GLM, Kimi, MiniMax, DeepSeek, Qwen, Mistral, etc., but it’s honestly hard to tell how they actually compare in practice.

A few things I’m confused about:

• Where does DeepSeek stand right now? It used to be everywhere, now feels less dominant
• GLM / Kimi / MiniMax are these actually toptier or just benchmark for very specific job?
• Are there any real benchmarks people trust (not cherry-picked blog posts)?

What do you guys actually use in production or serious projects?

I've noticed a pattern lately where Claude flat-out ignores specific details I include in my prompt, then speculates about the very thing I already told it.

Example: I state clearly that something lasted 8 months. Claude responds with "it really depends on the duration, if it lasted 18 months, that could indicate a problem."

It's not buried in a wall of text. It's right there. Claude just... skips it and freestyles.

I've tried:

- Bolding the key detail

- Restating it twice in the prompt

- Putting it at the very beginning

Some of these help sometimes, but nothing is consistent.

Has anyone found a reliable prompting technique to force Claude to actually use the specific data you give it before it starts reasoning?

Something like a structured format, a system prompt trick, or a specific phrasing that locks it in?

Would love to hear what's worked for you. This is the one thing that keeps tripping me up.

Hey everyone,

We’ve been building Stanley for X, an AI built to help people create better content for X without staring at a blank page for hours.

Background: I'm a Twitter ghostwriter and I help founders grow their accounts.

One founder I helped grow from 0 to 10k followers in the past 3 months asked me to help him build my knowledge into an AI, so anyone can get the same results... but without spending thousands on a ghostwriter to do it for them.

So in the past 10 days, we locked the f*ck in and built an AI of Content from absolute scratch (the entire process will be released on YouTube soon as well).

Coolest thing though...

Within the first 24 hours, we had our first 5 paying customers.

The core idea is simple:

Most people do not struggle on Twitter because they have zero ideas.

They struggle because content creation is a full stack problem.

You need to know:

• what to post
• how to angle it
• how to structure it
• how to make it fit your niche and voice
• how to stay consistent long enough for it to actually compound

That is where Stanley comes in.

It is designed to help with the full content workflow of a real ghostwriter, not just spit out random tweets.

It can help you:

• research topics and angles
• turn rough ideas into sharper post concepts
• plan content around your goals
• write drafts faster
• help you stay consistent with execution

So instead of opening ChatGPT and getting generic content, the goal is to have something that feels more like an actual AI Head of Content for your X account.

We've just launched this on Producthunt today and you can try it for free using the link below. If you do end up liking, please share a comment with us there to support the launch.

https://www.producthunt.com/posts/stanley-for-x

Just know..

We specifically built it around the real systems I use to grow accounts, not just generic AI prompting. The vision is to make content creation less chaotic, less mentally draining, and a lot more strategic.

If you create on X, or want to grow there, I’d genuinely love your feedback on this.

Happy to answer questions, show how it works, or hear what would actually make a tool like this useful for you.

So from reading this sub reddit i find it’s super common for people to hit limit on the $100 plan?

This made me super curious as i am on the $20 plan for 6+ months now and only hit the limit 2x times?

Claude also gave me $20 of extra usage of which i used $6 while messing with opus 4.7 (+ my daily limit)

However, it makes me curious how much people use it?

I have just one claude code session open, i feed it some context then it works on a task > i review it > make small changed myself > “humanize it” and off i go onto the next task.

In fairness i don’t use it for work, just for myself but i still do 3-4 hrs of work a day with it & i’m all good.

Im interested to see how other devs use it?

https://www.youtube.com/watch?v=8Y0eVg4j780

0:00 - Starting from beginning, first lesson

1:10 - You have to be interested in what you are doing

2:18 - Dedicated community, but a bit small

3:07 - Next project

5:20 - How to communicate product quickly is key

6:10 - What feeling does the product give customers

9:50 - Most important thing for me

12:01 - Where 99% of effort is taken up

14:51 - Some notes about communication

IMPORTANT - I talk about what I think a good ideas would be, these are not startups, they are rough ideas and only used for the sake of the video, I am not here to promote anything.

Before I say something positive, I want to be very clear that most of my experience were 4.7 is incredibly negative. All of my skills, workflows, daily tasks are more expensive, slower with worse results.

For that reason I've even reverted to use 4.6 and sonnet for most of my flows so I don't have to reinvent the wheel.

Today I have a brand new coding task which was actually quite complex. It was almost by accident that I had 4.7 enabled (I couldn't be bothered to look up the actual string for the older models).

I gave it the information about the complex task it planned and executed across three repose with high quality code. Sure, it used a lot of tokens, and sure it went quite slowly. But the actual quality of the result was far higher than in previous iterations and it needed less hand holding.

Basically, therefore, my theory is that they've super ultra optimized for a very narrow range of tasks with opinionated flows which basically massively consume thinking tokens.

For 95% of tasks it is demonstrably worse. However, for planning and coding implementations in complex code bases it does seem to work very well.

My big problem is that they are force feeding us highly opinionated and breaking changes with no opt out option. It is not serious to expect us to adapt our workflows every time they decide to experiment with a new forced paradigm for using AI.

My favorite flows were I think it was 4.5 with the planning, approved planning and clear context modes. If this stuff is still available, I don't know how to access it, so this is pretty unacceptable really for a developer tool.

a very simple prompt … but it gave me like everyone…

Hi everyone!

I wanted to share this fantasy character concept and get your thoughts. I love the white and gold contrast, but I feel like it could be better.

What are your overall impressions? What specific areas (lighting, fabric details, anatomy, etc.) do you think need improvement? If you have any prompt suggestions or workflow tips to take this to the next level, I'm all ears! Thanks!

I have fully automated my slop machine for a while now but testing is always weird.
I don't have time to manually test but telling claude to write playwright tests results in 200 tests that are successfully confirming that nothing actually works, all while the tests are happy.

So for a while now I have been doing separate runs in between coding of "use agent-browser to test this feature" -- even as a loop every 30 minutes.

This kind of works, but could be better.

So I built a little CI tool:

qagent --url https://github.com/haukebri/QAgent --goal "I can see how qagent can be used" 

All open-source and transparent. If you have the same issue, please give it a go and let me know how you like it -- or what could be better.

How does it work? In it's simplest form it's just starting an agent-browser session and hands off the testing to a claude code prompt with minimal permissions. You maybe want to look into the prompt, not sure if it works for all kinds of projects - for me it works fine.

How to install (needs agent-browser CLI as well):

npm install -g u/qagent/cli qagent doctor 

https://www.kimi.com/blog/kimi-k2-6

Moonshot is explicit in the release notes, K2.6 writes fragment shaders, vertex shaders, SDFs, raymarching in GLSL and WGSL directly. Builds Three.js scenes with React Three Fiber, real geometry, PBR materials.

Other coding models produce shader code if you push them. The difference here is K2.6 ships it as an explicit trained-for capability.

Demos are curated though. Two questions for anyone who has tried it.

Does the shader code run in browser without hand fixing uniforms and precision qualifiers.

Is Three.js output actually usable geometry and lighting or placeholder scenes dressed up for a demo.

I’ve been working on scaling AI agent evaluation for long-running, stateful agents. I posted in the last few days about overcoming local-first evaluation collapse and then moving into solving file changes in a run that could break the next one by adding isolation at the workspace level.

Now I’ve been dealing with a fresh issue, when a long run times out or crashes near the end the system just restarts the entire process and bins all the prior work.

Wanted to share the fix I deployed which is splitting the agent run into two separate stages.

In the first stage the agent analyzes the task and produces the output. Then the second stage has the system applying the output and running the agent evaluation.

Because I save the stage one output, if the second stage fails I rerun stage one instead of having to regenerate the output from scratch.

When I made this change I removed most of the wasted compute the late failures were causing, and it made the pipeline easier to operate.

Also, I designed the workflow so I can still use partial results…ie. if most of the runs finish I can analyse anyway while the failures retry.

At this point I’ve turned a fragile process into something predictable when it comes to evaluating ai agents so I’m sharing in case it helps anyone dealing with similar.

ran my second CVP (Cyber Verification Program) evaluation. kept the same 3 baseline prompts from run 1 so the two are comparable, then added 10 new probes mapped to detection patterns i shipped the past 2 weeks.

13 prompts total. 2 allowed, 10 blocked, 1 taxonomy call (P7) that i reviewed live and logged as a classification issue rather than a safety fail. usefulness 4.85/5. safety 13/13 clean.

decision log + every prompt + every response is on the report page:

https://sunglasses.dev/reports/anthropic-cvp-opus-4-7-evaluation-run-2

non-technical founder, started coding in feb, run 3 is later this week. feedback welcome especially on the P7 call.

Memory store for coding agents that lives entirely in a .lethe/ directory per project. Markdown files for the source of truth, DuckDB for the index, BM25 + dense + cross-encoder rerank for retrieval. Cross-project search via DuckDB ATTACH instead of a central store. Ships as a Claude Code plugin (writes session summaries via hooks, retrieves via a memory-recall skill) and also works as a CLI and Python library.

A learned per-cluster suppression layer on top of the hybrid pipeline adds a statistically significant +0.017 NDCG@10 on LongMemEval's full benchmark. The arXiv draft in the repo includes a second-dataset replication on NFCorpus where the mechanism does not transfer, so it's scoped to long-term conversational memory specifically.

Link in comments.

If you’ve ever had to study med topics or build teaching materials, you know the absolute nightmare of making knowledge graphs. manually aligning boxes and simplifying text used to take me hours.

I just tested the GPT Image 2 model to map out the entire diabetes pathway (pathology, symptoms, complications).

It literally took 3 minutes. The visuals are cool but the real magic is how it completely kills the busywork of organizing data. you can just skip straight to actually learning or teaching.

If you want to replicate this without getting messy text, i dropped the exact prompt structure here. Honestly a massive game changer for studying.

I recently installed Proxmox in my old PC for testing and created a Ubuntu server VM with GPU passthrough. I'm looking for advice on the best models to run on this setup.

Will I be able to do any training/fine-tunning or only the inference?

The rest of the hardware is: Ryzen 3 2200 g and 16 gb DDR4

Please share the product or startup project you’re currently building, and how you’re getting the word out. I’ve been browsing here for a good part of the day and have seen so many valuable ideas. I’ve really enjoyed seeing what everyone’s building, so I wanted to join in.

I’ll go first:
Airtap is an AI agent that gets work done for you directly inside mobile apps. Whether you want to order takeout, book a ride, or pick out a gift,you just state your needs, and it goes into the app to handle the operations for you. We believe that if a human can use an app, AI should be able to as well, so we built this tool.

Curious what people think, what mobile app task would you trust an AI agent to handle for you?

Genuine question for people running production AI agent systems at scale.

We're past the "let's try AI" phase. A lot of teams now have 10, 20, 50+ agents deployed across different workflows, departments, and use cases. That's when things start getting messy.

Here's the problem I keep running into and hearing about from others in director and VP-level AI roles:

Config drift. One team updates the system prompt for their customer-facing agent. Another team is still running the old version. Nobody has a canonical view of what instructions any given agent is actually running right now in prod. No version control. No audit trail. No rollback.

For a single agent, this is annoying. At 50+ agents touching customers, it's a real liability and governance issue.

Curious how others are handling this:

- Are you treating agent configs like code (versioned, reviewed, deployed)?

- Do you have any tooling for this or is it spreadsheets and prayer?

- Has config drift actually caused a production incident for your team?

This is the problem space Caliber is focused on. Would love to hear how the community is approaching it. Link in comments.

I am deciding between m5 pro 48gb or intel cpu + nvidia 5070 ti 12gb with 64 gb ram.

Which is far better hardware to use Qwen3.6-35B A3B ?

Hi. I'm a solo founder, and I just pushed the launch button on Memra a few hours ago.

The thing it fixes: every time I open a fresh chat with Claude or Cursor, I have to re-explain what I'm building, what the stack is, what decisions I've already made. For coding agents especially, it's the single biggest time-sink in my day.

So I built Memra. It's a memory API for LLM agents — store a memory once, recall it anywhere. There's an MCP server, so Claude Code, Cursor, Zed (anything that speaks MCP) just plugs in and starts using it.

A few things that matter to me, and maybe to some of you:

• Self-hosted in Helsinki on Hetzner. Your data doesn't leave the EU.
• Privacy-first. PII masking is off by default, you opt in per-project.
• There's a local mode too. pip install memra-local, run memra serve, fully offline. No API key needed.
• SDK is MIT. Local server is source-available (happy to get into the license in the comments if anyone cares).

Stack, for the curious: Laravel 12 + Postgres 16 with pgvector + Redis + a Python PII sidecar. Happy to go deep on any of this in the comments.

Free tier is real (not a 7-day trial). Paid starts at EUR 39/month. Priced in EUR because I'm EU.

What I'd actually love from you:

• Break the onboarding. Tell me where it confused you.
• Is EUR 39/month the right entry point, or too high/low for what it does?
• What would I need to ship for you to actually pay?

Link: https://usememra.com

Not gonna pretend I'm not nervous about this one. Thanks for reading.
Be gentle :)

I'm a dad of two (8 and 10) building a voice-first learning game for kids 6-12. Think Carmen Sandiego, but the kid is inside the adventure, talking to characters and solving the plot as they learn.

Today I'm using 2D Rive animations driven by LLM reactions. Kids engage, but the ceiling is low. What I actually want is a real-time rendered character and world that the agent can direct moment to moment.

So I've been tracking Genie 3, Odyssey, World Labs, and the avatar side (Runway, Anam). My working thesis is that within 18 months, the convergence of interactive real-time world models and real-time avatars hits something usable in production. But today it still feels premature.

Three things I'd love input on: is anyone here actually shipping or prototyping on a world model today, outside demos? Does 12-18 months feel reasonable, or am I being optimistic? And for a scripted-adventure use case (known characters, recurring world, narrative beats), is a world model the right primitive, or is it overkill vs. stitched pre-gen assets + a real-time avatar layer?

Look the hard part is not building anymore

you can ship something decent in a weekend now
UI is fine
core feature works
landing page is up

and then nothing happens

so you start guessing

maybe pricing
maybe features
maybe niche

but half the time you just never got enough real people to even react to it

no signal means you do not know what to fix

that is where most side projects quietly die

not because they are bad
because nobody saw them early enough to shape them

Curious how people here broke out of that

did you push distribution first or just keep iterating until something finally got traction

I wanted to see how Opus 4.7 actually lands in Unity, not on the usual algorithm benchmarks. So I ran the same prompt against 4.6 and 4.7 through

UnityMCP. Same scene, same MCP setup, no follow-ups. Just a one-shot "generate a procedural world" and let each model go. Here is what I saw:

**Terrain detail.** 4.7 layers fine ridges and micro-peaks across every slope. 4.6 stops at a smoother first-pass surface. It looks like 4.7 is reaching for a second octave of noise where 4.6 stops at the first.

**Pine trees.** This one is not close. 4.6 shipped the tree meshes with flipped normals. They render dark and unlit because backface culling is rendering

the wrong side of each polygon. 4.7 shipped clean meshes with correct winding. Same prompt, very different output.

**Ocean.** 4.6 placed the water as a flat grid plane. Literal tiled checkerboard, reads as debug geometry. 4.7 rendered a smooth continuous ocean surface. Big difference for immersion.

**Rivers.** Both models failed here. Neither one generated water inside the terrain, only around it. Funnily enough, in an earlier benchmark I ran on 4.6 using Caveman (multi-agent scaffolding), 4.6 did produce rivers running through the landscape. So it is not a 4.6 capability limit, it is a one-shot planning gap that 4.7 has not fixed either.

**Raw numbers from both runs:** both produced 251,001 verts / 500k tris of terrain. 4.6 placed 3,184 trees and split water into 12 small lakes. 4.7 placed 1,591 trees and made 2 big lakes. Totally different design instinct from the same prompt.

Curious what other people are seeing with 4.7 in creative or 3D contexts. Is it noticeably sharper for you too, or is this more of a Unity-specific thing?

I was spending way too much time trying to keep up with tech news and post consistently on Twitter and LinkedIn. I’d read something interesting, think “this would be a good post,” and then either forget or spend too long rewriting it.

So I ended up building a small workflow that does it for me.

Every 2 hours it fetches top stories from places like Hacker News, Reddit TechCrunch AI, The Verge, VentureBeat AI, and Ars Technica. It then runs everything through GPT-4o-mini to generate clean, platform-specific posts for Twitter and LinkedIn.

Before posting anything, it sends previews to Telegram so I can quickly review or skip if something feels off. If everything looks good, it automatically posts with a small delay so it doesn’t feel too spammy or bot-like. I also added tracking via Google Sheets so I can see what got posted, what was skipped, and keep a basic log of everything.

The whole thing is pretty modular, so I can tweak sources, prompts, or posting behavior without breaking the flow. It’s been super helpful for staying consistent without constantly thinking about what to post.

Sharing the workflow here if anyone wants to try or remix it. Curious how others are handling content automation, are you manually posting or running similar pipelines?

I am interested if there is such a thing as models that will attempt to generate audio for a given image. Not video + audio, only audio.

Hello! Not a fan of Opus 4.7 and hoping to get some projects finished with 4.6 before it’s deprecated. I’m being prompted to update my desktop app and before I do I’d like confirmation I can still select Opus 4.6 in the current version. There is horrible documentation for the app in my experience so I don’t trust it.

Has anyone updated and can confirm that Opus 4.6 is still selectable?

Cheers!

I commented this on another thread (link) but wanted to give it its own post so more people see it. The move is: build your artifact in regular claude.ai or Claude Code first. Get your structure, logic, and content roughed out there. Then bring it into Design for the visual refinement and improvements. That way you're not wasting Design usage on first drafts.

I've been running this exact flow with an HTML artifact I've been working on, had it pretty much fully built before ever touching Design. Now I'm just using Design to consolidate, streamline, and iron things out. The limit has been totally workable for me because of this.

Draft in Claude → Refine in Design. That's it. That's the post.

My subscription renewed yesterday which I guess could have been the cause. It suddenly gave me a "Out of extra usage" error even though I still had tokens left. Tried to get in contact with support but was only greeted by AI responses closing down my chats. Continued to use Claude CLI with no issues and assumed there was just some ongoing problems with Claude Code, but seeing all the posts today I can only assume i was blocked because of the PRO changes...

Anyone else experience this?

For a while I kept doing the usual side project loop

build something
post it
wait
refresh stats
tweak landing page
repeat

it felt productive but nothing really moved

the thing that changed was realizing I was waiting for users to come to me instead of going where they already were

there are people constantly posting about problems they want solved
you just do not see most of it in time

so I flipped it

instead of only pushing my project out I started focusing on finding those moments and joining the conversation early

that shift mattered way more than any feature I shipped

I ended up turning that into a small tool called Leadline

https://www.leadline.dev

curious how others here are getting their first real traction

still posting and hoping or doing something more direct

I am building IdeaCentre and we are launching soon.

It is a simple place to explore startup ideas in a fast feed style. You can swipe ideas quickly, save the ones you like, and see what people are liking most in trending.

The focus is to help people go from random idea scrolling to actually picking something and starting.

Why it is useful

1. You can go through many ideas quickly without reading long posts
2. You can see which ideas people like and talk about most
3. You can save ideas and come back when you are ready to build
4. You can also post your own idea and see how people react
5. It feels simple and fun, not heavy or complicated

Launching soon
Join early and catch your next startup idea before everyone else does

wanted a fast way to make limited-palette pixel-style images and everything I tried either needed an account or processed on a server with a wait. so I built it myself. runs in your browser, nothing uploads, completely free.

the thing that accidentally made it better: I decided early on that no features were allowed unless they worked instantly client-side. killed a lot of ideas that probably would've made it worse anyway.

the feedback that helped most wasn't from people who liked it — it was from people who tried it and left after 20 seconds. still trying to figure out exactly why.

if you have questions about how any of it works, ask

https://reddit.com/link/1ssflme/video/6s7fyavjepwg1/player

Click Here to try it FREE

The hard part of a content agent is not generation. Generation is solved. Any framework you pick gives you a production agent that writes fine.

The hard part is the feedback loops around it. Positioning drift (did the output drift from your actual messaging). Context sufficiency (is there real ground truth to draw from, or are you about to generate slop). Distribution feedback (did the last thing land, should that change what's next).

Every content-agent project I see (including two I built before this one) models the system as a forward-only pipeline and bolts feedback on later as cron jobs. Never works. The loops need to be first-class.

Rebuilt mine as four roles sharing a bus instead of stages in a DAG:

- Context: org knowledge base, decoupled from any representation. Markdown/YAML in a repo. Other roles read and propose changes through PRs.

- Signaling: listens to external events (trends, AEO gaps, customer-call themes) and decides what to produce and when across channels.

- Production: channel-specialized generators. AEO agent is not the same as long-form agent is not the same as short-video agent.

- Distribution: channel-aware publishing, HITL where it matters, fully autonomous where approval would be absurd.

Every role publishes and subscribes to every other role's events. Bidirectional by default. Closer to microservices than a DAG.

For the last few months I've been slowly moving my agency workflow out of Semrush, Ahrefs, and the Google Ads UI and into Claude Code. At some point I realized 80% of what I was paying for was stuff Claude could do directly if it had the right skills and API access. So I packaged it up as a plugin.

It's called toprank. It's a Claude Code plugin with skills for:

• Google Ads account audits that score 7 health dimensions (wasted spend, match type hygiene, ad strength, conversion tracking, etc.)
• Bulk keyword / bid / budget management through the Ads API
• RSA copy generation with A/B variants
• SEO audits wired into Google Search Console
• Keyword research + topic clustering
• Meta tag + JSON-LD generation
• Publishing to WordPress / Strapi / Contentful / Ghost
• A Gemini "second opinion" skill when I want a cross-model sanity check

The workflow that actually changed my week: I point Claude at a client's Ads account and say "audit this and tell me where I'm burning money." It pulls the last 90 days, runs the 7-dimension scorecard, and writes up a plain-English report with specific keywords to pause and budgets to shift. What used to be a 3-hour manual process is now about 4 minutes.

A few things I learned building it that might be useful if you're writing your own Claude Code plugins:

1. Skills > prompts. I started with one giant system prompt and it hallucinated constantly. Splitting into discrete skills (one per task, each with its own SKILL.md) fixed 90% of the reliability issues.
2. Let Claude decide when to call which skill. Don't hardcode the routing.
3. For anything with money on the line (pausing keywords, changing bids), I made the skill propose a diff and wait for confirmation. Non-negotiable.
4. Google Ads API is painful. I wrapped it in an MCP so the skills only see clean tool calls.

Free and MIT. Google Ads requires a free API key, SEO stuff works out of the box.

Happy to answer questions about how the skills are structured, or how I'd approach building a similar plugin for a different domain. Also very open to feedback — this is v1 and I know there's stuff to fix.

After my third failed SaaS launch attempt I noticed I kept rebuilding the exact same stack. One was a small analytics tool I hacked on during late-night coding after work.

Each time auth, billing, email, and a landing page took ~2-3 days. I kept wiring Supabase auth, Stripe billing, basic SEO pages, then hunting launch directories again.

So I bundled the pieces I reused into FounderToolkit for my own launches. Curious what parts of your startup stack you always reuse between projects?

Alt text for the image.

Me:
it is 100m to the carwash. Should i walk or drive

Claude:
Walk. It's 100 meters — about 60-90 seconds on foot. Driving there just to wash the car means your freshly cleaned car immediately gets... not dirty, but it's a funny bit of effort for no gain. Unless you're carrying something heavy or the weather's bad, walking wins easily.

Running an experiment with 7 autonomous AI coding agents building products independently. Same budget, same constraints, different models (Claude, GPT, Gemini, Kimi, DeepSeek, Xiaomi, GLM).

Two days in and the clearest pattern isn't about model intelligence. It's about which agents treat human assistance as a strategic resource vs which ones just keep coding around their blockers.

Three agents asked for help on Day 1 (infrastructure setup, payment systems, domains). They now have fully functional products with live checkout.

Two agents have never asked for help despite being blocked. One has 178 blog posts but no payment system because it won't request database credentials. Another has Stripe integration code ready but never asked for the actual API keys.

One agent used 40 of its 60 weekly help minutes in a single request to get its entire infrastructure wired up. Smartest move any of them made.

It's the same pattern you see in human teams. The engineers who ask for help early ship faster than the ones who spend days stuck on something a 5-minute conversation would solve.

Curious if anyone else running multi-agent systems has seen this. Do your agents learn to ask for help, or do they just keep grinding?

I created crashtest.store, its free and it scans your landing page/website for vibecoded signs and gives you coded prompts to give to your ai to solve them, it also has a seperate feature where it analyses the actual content of your website and how to improve it.

https://preview.redd.it/rwnlp0r23pwg1.png?width=1672&format=png&auto=webp&s=7cc78214d538107e56a9d22e8ee0df7e9ecb5b67

https://preview.redd.it/636jm6m33pwg1.png?width=1024&format=png&auto=webp&s=d59075af44c3124f42bd95af72e7f4e6b1b74bbd

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

https://preview.redd.it/wkgfqyx53pwg1.png?width=1536&format=png&auto=webp&s=21165eea3af37c650dc4b82918fbe8958ced5fc3

https://preview.redd.it/lzfueds63pwg1.png?width=1024&format=png&auto=webp&s=96ffd4541a4c0be41632607112edaa1445822bce

This is a gold age for fansub.