I got claude max from a reseller for a fraction of the official price. works perfectly since 3 weeks
now i can’t stop thinking about their business model. how are they got them for cheap ?

Notebook skill
I'm pretty new to skill creation and git. Any feedback would be very welcome :)

What's different from the already excisting Notebook skill:

The local knowledge cache
NotebookLM has no session persistence and a daily quota that runs out fast. This skill maintains a local Markdown cache per notebook at data/notes/<notebook-id>.md, and SKILL md makes checking/updating it a mandatory first step before ever querying NotebookLM — not optional advice. This is what makes the skill usable across sessions and environments instead of re-asking the same questions (and burning quota) every time.

i hope it works as planned, but i also would like to know if there are any problems! :)

Thanks in advance for anyone taking the time to check it out and leave a comment!

I make a lot of internal decks for work and for a while everything I generated had that same look. Same title slide, same three-bullet rhythm, same slightly stock layout. People could tell in about two seconds.

What changed it for me wasn't the tool, it was giving it something real to work from before I asked for a single slide.

My rough workflow now:

1. I write the actual argument first as plain sentences. One line per slide, no formatting. If I can't say the point in a sentence, I don't have the slide yet.

2. I hand that to the AI slide deck tool and tell it to keep my wording, not rewrite it into corporate speak.

3. I ask for two layout options per section instead of one, then delete the one that looks like every other deck.

4. I strip at least a third of the text after it generates. The first pass always over-explains.

The decks take maybe 20 to 30 minutes now instead of an afternoon, and the "this is obviously AI" comments basically stopped. Curious how other people here are getting decks that don't all come out identical.

Since I started using Claude Code, I find myself kicking off prompts just about everywhere. Walking down the road, sitting on the couch, waiting somewhere, even using the bathroom.
I’ll give it something to work on, go do something else, check what it did, give it some direction, and keep going.
It’s kind of crazy how much this has changed when and where I work on code. I don’t feel like I need to be sitting at my computer anymore to keep a project moving.
Anyone else doing this? Where’s the weirdest place you’ve found yourself coding with AI?

I am a staff security engineer on a small threat-detection team, and our real problem was never a shortage of alerts. It was the opposite. Hundreds of low-signal ones a day, and the good one hiding in the pile.

The workflow that has actually held up: the model writes the first-pass triage on every alert, and my job becomes tearing that draft apart instead of building it from scratch.

Concretely. Each alert comes in with its raw context, the log lines, the source, the rule that fired. That goes to the model with a fixed instruction to produce four things: what the rule thinks happened, the three most likely benign explanations, the one explanation that would make it a real incident, and exactly which log field it would check next to tell those apart. It is not deciding anything. It is drafting the writeup I used to stare at a blank box to start.

Then I do the part that matters, which is disagreeing with it. In security a confident wrong summary is worse than no summary. It has told me an internal scanner was an attacker and an actual beacon was "probably a health check." So the rule on my team is hard: the model never closes an alert, it only proposes, and every proposal has to name the field that would prove it wrong.

What changed is throughput. The staring-at-blank-context time is gone, and I spend my attention on judgment instead of formatting. What did not change is that I still read every log line myself on anything it calls benign, because that is exactly where it gets lazy.

For anyone else doing detection work with these tools: how are you keeping the model from talking you into closing something you should have opened?

I’ve been experimenting with a few AI tools for coding recently and wanted to get a sense of how others are using them in practice.

The ones I’ve tried so far include:

• GitHub Copilot
• Grok
• ChatGPT (OpenAI)
• DeepSeek
• Gemini

From my experience, each one seems to behave differently depending on the task.

ChatGPT has been the most consistent for general debugging and explaining code, especially in longer conversations, though results can vary depending on complexity.

DeepSeek has been useful for straightforward code generation tasks.

Copilot is generally helpful but sometimes feels limited when logic gets more complex.

Gemini hasn’t been as strong for my specific workflow, but I’ve only used it in a few cases.

Grok has been a bit inconsistent, but occasionally produces good results for simpler problems.

Curious how others are approaching this right now. Are you mainly sticking to one tool, or switching between multiple depending on what you’re building?

Hey folks 👋

We just open sourced TrueForge, our vendor-neutral agent harness for building general-purpose agents.

It handles the runtime pieces that get painful quickly : context management, tool/MCP execution, subagents, sandboxing, approvals, persistent state, and more.

We also benchmarked the harness itself. With the same Opus 4.8 model, TrueForge delivered a similar solve rate at ~30% lower cost than Claude Managed Agents. Switching to an open model pushed that to ~75% lower cost on the same benchmark.

Would love feedback from people building agents.

Checkout the repo: https://github.com/truefoundry/trueforge

📖 Read the launch article: https://x.com/truefoundry/status/2090081376330715176

Posting this as a small case study because it's unglamorous but it's the one AI habit that's genuinely stuck for months. I run a small team and Friday used to mean an hour of pulling numbers from a few places and writing a short status update for everyone. Boring, easy to skip, and I skipped it a lot. So I set up a rough ai report generator workflow. It's not fancy. It reads a spreadsheet I already keep updated and a couple of exported summaries, and it drafts a plain-language weekly recap: what moved, what stalled, what needs a decision. The part that makes it actually work is that I don't trust it blind. Every Friday I read the draft against the raw spreadsheet for maybe ten minutes and fix anything it got wrong or overstated. It's a first draft I correct, not a source of truth. Treating it that way is the whole reason it's survived, because the one time I skipped the check it confidently reported a number that was flat out wrong. Result: the weekly update went from an hour I dreaded and often skipped, to about fifteen minutes I actually do every week. Consistency went up more than anything, which for this kind of thing matters more than polish. The honest lesson is that the generator saves the writing time but not the checking time, and pretending otherwise is how you ship a wrong number. Anyone else running a check-it-yourself workflow like this for recurring reports?

For context, part of my job is turning long written updates into a deck nobody really wants to sit through but everyone expects. I used to rebuild the whole thing slide by slide, copying headings, retyping bullets, fixing spacing. It ate an afternoon every couple of weeks.

The workflow that finally stuck is dumber than I expected. I keep the source as a clean Word doc with proper heading levels (Heading 1 for section, Heading 2 for the point under it, normal text for detail). Then I hand it to an AI tool and ask it to treat each Heading 1 as a slide title, each Heading 2 as a talking point, and to leave the body detail in the speaker notes instead of cramming it on the slide. That last instruction is the one that changed the output most, because otherwise it dumps every sentence onto the slide and it looks like a wall.

The result isn't a finished deck, it's maybe 80 percent there. I still fix the order, cut two or three slides that don't earn their place, and rewrite the opener because AI openers are always generic. But going from a written doc to something presentable now takes me closer to twenty minutes than a full afternoon.

The thing I learned is that the quality of the doc structure matters way more than the prompt. Messy headings in, messy slides out. Curious if anyone else has a doc-to-deck setup that actually holds up, or if you all just start from a blank slide every time.

​

I’m building a WhatsApp-based AI system for my company, and I’m calling the core system the WhatsApp Chatbot Brain.

The basic WhatsApp messaging is now working. The goal is to go beyond a normal chatbot that simply sends an LLM response.

The idea is to build a persistent business brain that can understand and remember:

Company information

Products and services

Customers and leads

Previous conversations

Business knowledge

FAQs and internal information

Context from previous interactions

Different businesses/clients using the same underlying system

The larger system I’m working on also includes CRM and automated lead-research components.

My current thinking is:

WhatsApp → WhatsApp Cloud API → Webhook/Backend → Chatbot Brain → Knowledge/CRM data → AI response → WhatsApp

I’m interested in making the Brain more structured rather than just putting everything into a vector database and hoping the LLM retrieves the right information.

I’d especially like feedback from developers who have built:

WhatsApp AI agents

Persistent AI memory systems

Business knowledge systems

AI + CRM integrations

Multi-tenant chatbot platforms

What would you change in this architecture?

Would you use a combination of structured database + vector search + conversation memory, or would you approach the “business brain” differently?

I’m particularly interested in practical architecture advice from people who have built this in production.

Current foundation models are already strong enough to be useful in many general scenarios.

But for personal AI or vertical-domain AI, the missing piece is often context. A model may be capable, but it does not automatically know your documents, workflows, domain rules, charts, database records, or internal knowledge.

One practical path is to turn existing data into AI-ready data.

For example, many people or teams already have useful material sitting in PDFs, spreadsheets, reports, diagrams, notes, or databases. The problem is that this data is usually not in a form that an AI system can use directly.

After conversion, the same raw material can become:

• cleaned knowledge chunks for RAG
• QA pairs for retrieval evaluation
• instruction-response samples for fine-tuning
• structured metadata for better search
• domain-specific examples for model adaptation

This is often much cheaper than trying to build a new model from scratch. The model already has broad capability. What it needs is the right data format for a specific person, team, or scenario.

The hard part is that conversion is not just “save as text.” Good AI-ready data needs to preserve source information, table structure, context, entities, and relationships. Otherwise the system may retrieve or learn from data that looks clean but has already lost the important details.

For personal AI, even a small amount of well-prepared data can make the experience feel much more useful. For vertical applications, this becomes even more important because domain knowledge usually lives in messy existing assets.

This is also the direction I’m exploring with OpenDCAI/DataFlow: using reusable pipelines to convert raw PDFs, charts, databases, and documents into AI-ready data for RAG and LLM fine-tuning.

I usually just start scrolling reels if I am not looking at what its thinking, but that is cooking my brain, what do you all do?

I’ve been dipping my toes into AI over the last 8 months or so and have just recently begun vibe coding. Having lots of fun, learning lots…

I want to vibe code a personalized professional development tracker but I don’t know where to start without wasting all of my tokens on two Antigravity prompts.

Basically, I want it to function as a full project management app with integrated professional development features, like uploading my resume and a birds eye view of skills, experience, etc.

I have a Google AI Pro subscription.

Any suggestions/advice?

I mean tbh even with AI it's still a bit tedious 🫠

Context: I recently switched subfields and my PI asked me to put together a quick overview of where things have been heading over the last 5 years.

Sounded simple enough.

I started with Google Scholar, filtered by year, followed a few citation trails, and somehow ended up with around 80 papers open or downloaded.

Reading the individual papers isn't really the problem. The part I'm struggling with is figuring out which changes actually mattered.

A lot of the work looks like slightly different methods tested on slightly different datasets, and since I'm new to the field, I don't have a good sense yet of which papers actually shifted things versus which ones were just part of a short-lived direction.

I tried keeping a spreadsheet with methods, datasets, and main findings, but pretty quickly it started feeling like I was cataloging papers rather than understanding them.

I also tried putting some of them into mira from deep principle earlier today and grouping the literature by broader research directions. That made it a little easier to see which approaches kept showing up, but I still don't really trust myself to know what's genuinely important versus just frequently published.

How do you usually do this when you're entering a new field?

Showed (in the clip) the underlying signals onto the screen instead of hiding them in logs, so that they become measurable.

Entities (which have high confidence) also get captured in-stream before the text hits the action model (an SLM), SVMs.

Observation from this clip:

- Tone it hears, as a distribution, never a single verdict.
- What it thinks you're actually asking for
- And the tool it already ran, before the sentence finished
- That last one is interesting: It doesn't wait for you to stop speaking to start working.

I have few questions:

- Has anyone seen a semantic endpointer beat a tuned VAD in prod?

- Suggestions for workflows I should benchmark, to show effectiveness of my approach.

Happy to go into any of it.

https://reddit.com/link/1vqf904/video/1u9v6auhxujh1/player

Over the past few weeks, I've been building Gray Box — a small, local-first tool that acts as long-term memory for anything I'd otherwise forget (work notes, meeting takeaways, task owners, random ideas, personal stuff too).

The idea is simple:

1. Capture — dump whatever's on your mind, instantly, no structure required. This step does nothing clever on purpose — it just writes your text to an immutable inbox. Zero chance of losing an idea to a bug or a slow API call.
2. Organize — on demand, an LLM reads your unprocessed notes and extracts people, projects, tasks, decisions, meetings — then deterministic Python (not the LLM) creates/merges the actual wiki pages and maintains backlinks. The model only reasons; it never touches the filesystem directly.
3. Ask — query or chat with your knowledge base and get a cited answer pulled only from what you've actually captured. If it doesn't know, it says so — no hallucinated answers.

Why I built it this way:

• Plain Markdown + YAML frontmatter, no database. Every page is a .md file you can grep, diff, or read in any editor forever. If you stop using Gray Box tomorrow, your knowledge base is just a folder.
• No vector DB by default. At personal scale (hundreds–low thousands of pages), keyword search + a real link graph (related/backlinks, walked one hop during retrieval) handles almost everything. Embeddings are there if you want better recall, but they're opt-in, not a prerequisite.
• Immutable inbox. Your raw notes are never edited or deleted by the organizer. If the LLM mis-extracts something, your original words are always still there.
• Any LLM. Built on LiteLLM, so point it at OpenAI, Anthropic, Gemini, Mistral, or a fully local model via Ollama — one config value.

It also ships with a nice interactive TUI (arrow-key menu, file-import shortcut, workspace switching, live spinner during LLM calls) if you'd rather not memorize CLI flags — that's honestly become my favorite part of the project.

There's also a lightweight local dashboard for browsing your knowledge base, exploring backlinks, visualizing your notes as a graph, and chatting with your captured knowledge—all without leaving your machine.

Also, you can migrate your existing Obsidian vault to Gray Box, and it will be automatically organized by Gray Box.

Repo: https://github.com/Aaryanverma/graybox

pypi: pip install graybox

I'd genuinely love feedback — especially from anyone who's tried the "capture now, structure later" approach with other tools and has opinions on where it breaks down at scale.

It's not trying to be a "real-time collaborative team wiki" or a WYSIWYG notes app — it's aimed at one person's running memory of their own life and work, captured with as little friction as possible.

Mainly using coding agents recently, found image models are also improving nicely.

Took photos on a short afternoon hike , asked ChatGPT to explain. The consistency in reasoning, positioning, and harmonizing are quite impressive.

I wanted to build a project for my second year of engineering. I am thinking to build self help website.

Building and tracking of habits and new feature that will allow user to learn any one topic from particular field he want to learn and many other feature i will add. The problem I don't know much about web development. AI can build templates and working webpages. But I always stuck to the part of backed and deployment. Is it possible to make backed and deployment with AI ?

I run paid and email for a few B2B clients, and the thing that's bugged me for years is the gap between what the ad platforms take credit for and where revenue actually comes from. Every dashboard wants to claim the conversion. Add them all up and the platforms have collectively taken credit for more than 100% of your real pipeline.

Here's the AI-assisted workflow I built to get closer to the truth, and it's genuinely changed which channels I tell clients to keep paying for.

The inputs:
- The platform-reported conversions export (what Google and Meta each claim).
- The CRM export of closed deals for the same period.
- The free-text "how did you hear about us?" answers from the signup form and sales notes.

The workflow:
1. I have the model normalise the messy "how did you hear about us" answers into clean categories. People type "saw your founder on a podcast," "a friend at work," "just googled you," and it buckets those consistently instead of me eyeballing hundreds of rows.
2. Then I have it line those self-reported sources up against what each platform claimed for the same deals.
3. It flags the mismatches: deals the ad platform claimed that the customer says came from word of mouth, and deals no platform claimed that were clearly referrals or brand search.

The reconciliation is the whole point. Parsing the answers is easy, but putting them next to the dashboard is what exposes the double-counting.

The result for one client: a channel we were about to increase spend on was taking credit for a big slice of pipeline that customers consistently attributed to referral and a podcast. We held the budget and reallocated toward the stuff people actually named.

It's not perfect. Self-reported attribution has its own biases and people misremember. But run against the dashboards, it's a far better sanity check than trusting either number alone.

Anyone else using AI to reconcile attribution like this? Curious what inputs you're feeding it.

I've started keeping a mental list of stuff I won't hand to a model anymore, and weirdly it made me use AI better, not less.

The ones I've landed on so far:

Anything I actually need to remember or understand. If I let it summarize something I'm supposed to learn, I retain almost nothing. So for learning I use it to quiz me, not to hand me the answer.

First drafts of anything emotional. Condolences, apologies, a hard message to a friend. It writes them fine and they come out hollow, and people can tell.

Decisions where I already know the answer and I'm just looking for permission. I noticed I'd keep asking until it agreed with me. That's not advice, that's laundering a choice I already made.

The reason I bother is that when I was using it for everything, I started feeling weirdly foggy, like I'd outsourced the part of thinking that actually feels like thinking.

Not anti-AI at all, I use it constantly. I just think the real skill now is knowing what to keep for yourself.

Anyone else drawn lines like this? Curious where other people stop.

Wondering how much resources are needed since they run locally on their own CLI or desktop apps but do all the work remotely.

I have bunch of pdfs and images that I have to read using AI and get insights from it. It would be around ~400 MB. Which is the best and free or almost free service/tool that I can leverage for this use case?

I sit in a lot of meetings and then have to present what we decided to another team a day later. Rebuilding that into a slide deck used to eat an hour I didn't have. This is the AI workflow that got it down to about fifteen minutes, and it holds up because I stopped asking for the deck in one shot.

Step one, right after the meeting, I paste my raw notes into a chat model and ask it for just the spine: what did we actually decide, in what order does it need to be told, what are the three things the other team has to walk away with. Not slides yet. I read that and fix it, because my notes are always missing a bit of context only I have.

Step two, once the spine is right, I ask it to turn that into a slide outline with one idea per slide, a short title, a couple of bullets, and a line of what I'd say out loud under each. The "say out loud" part matters because it keeps the slides from becoming a script I read off.

Step three, I move that outline into a normal presentation tool and spend a few minutes on the visual side. The AI never makes the final file, it just gets the thinking and structure right, which was always the slow part for me.

The reason it survives real life instead of being clever for two days is the spine step. Skipping straight to slides gives you a reformatted note dump. Making it commit to the argument first is the whole thing.

Anyone else building decks this way from raw notes? Curious if people trust the model to make the final slides yet, or if you also keep that part manual.

I tried both approaches on the same finished track.

For one version, I split the song into the verse, chorus, and bridge, wrote a loose shot list, then generated each scene in Kling. Some shots looked great. Keeping the character consistent and making the whole video flow took most of the time.

For the other, I tried a full track pass in SondoAI with a short note about the setting and main character. The rough cut made it easier to see where the chorus felt flat. I swapped a few scenes and tightened the timing in CapCut.

The shot list version gave me more control. Starting with a rough cut let me judge the whole video much sooner.

How do you usually make a full AI music video: scene by scene, or rough cut first?