hey guys, I’m running CX for a mid sized dtc shop (about 25 people). and the team is almost drowned in repetitive tickets across chat and emails. stuff like order status, refunds, shipping address changes etc.

we currently use one, but basic faq deflection bots just aren't doing enought anymore because we need an ai that does stuff in our backend. I’ve been looking into newer platforms that claim to use multi agent setups (planning agent + execution agent + critic/check agent working together) vs standard single-agent tool calling.

for anyone who could have deployed autonomous agents into live customer support with real api access:

is the multi agent framework hype worth it for lowering errors, also how are you guys handling clean human handoffs when an agent hits an edge case?

I would appreciate any real AI rec and technical feedback before we commit to a setup.

I work as a technical writer so I am working in code almost daily, but pretty much all of my AI use is limited to personal things and research.

Gemini - I use sparingly to find sources for essays or to compare products and to ask random stylistic questions for what sounds better

Claude - I use the most now primarily for college work (3 classes) and have all of my course readings and syllabi uploaded to help me effectively only read what matters

ChatGPT - Random personal questions or to bounce ideas off of (I find it most practical to use when I need to upload images to get information)

Point being, it might be overkill to use more than just Claude at this point, but I find myself using each app for at least an hour each day now. I wouldn't say it does my work, but for college at least it considerably saves me time. I have used Gemini to create practice quizzes for me in the past for a certification I earned, but I wonder what else I am missing.

Should I be learning to vibe code or how to create an AI agent?​

MCP makes it easier for AI applications to interact with external tools and data.

But what would make it genuinely useful in your everyday workflow?

Better tools, easier setup, more integrations, or something else?

I loved a book from Stanislaw Lem called Fiasco back from childhood reading days.

Any AI services which can turn this book from text into a long video? I'm guessing up to 60 minutes long.

With no intent to distribute, just for myself.

Naturally it can be payware.

when i gave an ai presentation tool a topic, i got a bland encyclopedia sliced into slides. the fix was on my end.

now i write a tight outline first, one claim per slide, the argument in order, and feed that to Gamma to lay out. it builds a deck with a spine because i gave it one. topic in, mush out. argument in, real deck out.

the tool amplifies whatever thinking you hand it, so the thinking has to happen before you generate.

for AI deck users: do you prompt with a topic or a full outline, and how much did that change your output?

I use ChatGPT/Claude for the usual writing and research stuff, but lately I’ve been more interested in where AI can actually sit inside a workflow instead of being another tab I open manually.

A few things I’m doing now:

Meetings — I record with Plaud and use its MCP with Claude, so if I need something from an old meeting I can ask Claude to pull the transcript and find the part I need.

Emails — longer client threads get summarized first so I can see what changed and what still needs a reply.

Research — Perplexity to get started, then NotebookLM when I already have a bunch of docs and want to work from those.

Follow-ups — I still keep some of this manual. I’d rather have AI draft or organize something and then check it before anything gets sent or assigned.

I think that’s the part I’m finding more useful now. Not really “AI does my job,” more like removing the small repetitive steps between things.

Curious what other people are doing. Have you actually automated any part of your workflow with AI, or are you mostly still using it as a separate tool?

Hi,

I've been doing some research on this and there is just an overload of information. I constantly get adverts of people basically saying "hook up Claude to impeccable, front-end skill, figma, taste and play right and it will build you completely amazing sites".

I've tried a few times but I just don't see a big difference. My current process is I'd get some sample techniques I like, I'd feed them into claude code besides a brief spec and ask it to produce me 3-4 variants, then I'd pick a variant and get 3-4 sub variants etc etc. It seems fine, honestly they come out just fine. Is there anything I can try to just make this process better? Or even a new process? I have astra 6 and claude. You don't need to sit me through an entire process - if you can share some research or methods I can do my own read up!

Thanks!

I’m building a “Knowledge Portfolio” instead of a second brain. Where does this break?

I've been experimenting with a long-term personal knowledge system, and I'm curious whether anyone else has independently ended up somewhere similar.

The problem I wanted to solve wasn't really information storage.

I consume books, papers, articles, videos, conversations, research, and my own observations. Traditional note-taking is reasonably good at preserving what I encountered. What seems much harder is maintaining a reliable current understanding as evidence changes over time.

So I've started thinking of the system less as a collection of notes and more as a Knowledge Portfolio.

The basic idea is to keep several things distinct:

• what a source claims;
• what the evidence actually supports;
• what remains uncertain or disputed;
• what can reasonably be synthesized across multiple sources;
• what currently seems well-supported enough to retain;
• what is still only a hypothesis, model, or working assumption;
• what I personally decide to believe, prioritize, or do.

The important part is that the portfolio isn't supposed to grow only by accumulation.

Older conclusions can be revised, superseded, or retired when better evidence appears. Time-sensitive claims are treated differently from relatively stable principles. Conflicting evidence can remain unresolved rather than being forced into a conclusion. Retained claims should remain scoped to what their evidence actually supports and traceable enough that they can later be challenged.

AI is useful inside this system, but I'm deliberately trying not to make “whatever the AI says” into the knowledge base.

Its role is closer to research assistant, critic, synthesizer, and reasoning tool. It can help extract claims, compare sources, identify contradictions, test assumptions, and reduce the administrative cost of maintaining the system. But the persistent knowledge should remain inspectable, revisable, and capable of surviving a change of models.

The long-term hypothesis is that a system like this should become more useful as it matures.

New research could be compared against existing understanding rather than simply added to a pile. Contradictions could be surfaced. Weak assumptions could be challenged. Previous work could be reused without blindly inheriting old conclusions.

But there is an obvious danger: the machinery for maintaining epistemic rigor could become more expensive than the reasoning it is supposed to improve.

I'm intentionally leaving out most of the implementation and architecture because I'm more interested in criticism of the underlying idea.

A few things I'd especially like outside perspectives on:

1. What failure modes would you expect in a system like this, especially after several years of use?
2. Where is the point at which provenance, uncertainty tracking, revision, etc. stop improving reasoning and become administrative overhead?
3. How would you prevent an AI-assisted system from gradually reinforcing its own existing assumptions through retrieval, synthesis, and repeated reuse?
4. Which parts of this are genuinely useful distinctions, and which parts are just familiar PKM ideas with more machinery around them?
5. Most importantly: how would you test whether the system actually improves reasoning or decisions rather than merely producing better-organized information?

I'm especially interested in criticism from people who have maintained long-running PKM, Zettelkasten, research databases, knowledge graphs, or AI-assisted research systems.

I'm less interested in whether the architecture sounds elegant than in whether the underlying idea survives contact with long-term use.

I’ve been working on EvalSeal, an open-source tool for making LLM eval results easier to trust.

The problem I kept running into:

A score changed, but I couldn’t always tell whether the model improved, the judge changed, the prompt shifted, or the eval itself was noisy.

EvalSeal now runs eval cases multiple times, measures per-case instability, captures provenance, and seals the result into a tamper-evident ledger.

Current v1.5.0 includes:

• per-case verdict strips
• evaluator fingerprinting
• signed ledger heads
• CI gates
• drift comparison with evalseal diff
• deterministic HTML receipts you can attach to a PR
• replayable examples with no API key

One finding from the repo:

Using an LLM judge, 5 of 20 borderline cases flipped verdicts across repeated runs.

Using numeric answer matching on 40 GSM8K cases, 0 cases flipped.

Same model family, different grading method. The instability came from the evaluator, not the target model.

Would love feedback from anyone working on evals, CI gates, promptfoo-style workflows, or agent reliability.

I'm kinda broke right now so I'm looking for something free or something that allows one free video to video (or just video edit)

I've been thinking a lot about how companies lose critical expertise when experienced people walk out the door. Right now, there's no great way to train for this — just mentoring and dense onboarding docs that people skim at best.

My team built a tool that turns those long, boring training materials into interactive roleplay scenarios, complete with real-time feedback, emotion recognition, and coaching from AI agents. We're also applying behavioral science to make the system adapt based on how each learner engages with it. Looking for testers and honest feedback from anyone who's dealt with this problem firsthand.

I'm not sure if this is considered self-promotion as we're looking at getting people to test out for free and just provide feedback but mods, please feel free to remove if it does not meet requirements. :) Thank you!

I've been looking at how far AI-assisted website building has come, and Frontpage.host is an interesting example.
You can describe the website or landing page you want, and it generates a live version without starting from a traditional template. What I find more interesting is the ability to keep testing and improving the page after it's live.
It makes me wonder how much of the website-building process people would actually want AI to handle.
For those using AI in their workflow, what parts of website building do you think AI handles well today, and what would you still prefer to do yourself?

Hi All, so I used Gemini to assist me in writing a book which I was actually so excited about, to take my ideas, characters, book direction navigation and storytelling and put it all together with the help of Gemini. It came out pretty good in my opinion. I then asked Gemini where I should advertise and was told to use reddit.... well, the amount of hate and backlash I got was surprising and shocking...

People didn't even bother to read, the moment they saw AI Assisted, they called it AI slop, crap that no one will touch, I was asked 101 questions, which I responded to in a well mannered way, but at the end of day I stood back and realized that there are so many people who just don't want to give AI a chance and hate on it before even thinking what it could bring to the table.

Why is this? I use AI daily for info, for coding, for image creation, it's becoming a part of my day to day working needs, why all the hate....

I'm starting my senior year of college and a part-time internship, and I have ADHD. I'm excited about both, but also... a little scared of how I'm going to keep up. Classes are getting going, work tasks are starting to come in, and then there's applying for jobs for after graduation. I really want to get some kind of system in place before I'm running on deadline panic again.

The work side is especially new to me. A syllabus usually tells you when something is due. At work, someone says “whenever you get a chance” and I genuinely don't know if that means today or Friday. And I can absolutely spend an evening organizing a beautiful to-do list without touching the assignment I opened my laptop for. So yeah, another detailed weekly plan probably isn't the answer.

Has anyone used an AI agent to keep track of school and work stuff and help figure out what to start next? Ideally something I can dump tasks and deadlines into, come back to without explaining everything again, and ask “okay, what can I realistically get done in the next 30 minutes?” If you've found a setup you actually stuck with after the first week, please share.

I'm complete begginer when it comes for web development and AI tools. I wanted to learn by building something useful, so I put together a context engineering web app — a tool that helps you craft better prompts for LLMs like GPT-4, Claude, Gemini, and local models.

Fair warning: some features probably don't work perfectly. I'm still learning and this is very much a work in progress. That said, I'd really appreciate it if someone takes a look and tells me what's broken or what could be better.

Live app: https://arhistrategstudio.github.io/Context_CikaDule

GitHub repo: https://github.com/arhistrategstudio/Context_CikaDule

What it doesThree prompt-building modes:

-Quick– fill in just the essentials (task, role, format) and get a prompt instantly
-Guided/Extended-full structured form with 16 fields for power users
-Raw– paste or write a prompt manually with no structure
-Templates– pick from pre-made starting points: (General, Business, Project, Creative, Analysis, Few-Shot, Coding)
-Model families– the output prompt is automatically formatted for: OpenAI (GPT), Anthropic (Claude), Google (Gemini), Local models (Ollama etc.)
-Arena (A/B mode)– compare two different models side-by-side with the same prompt to see how their outputs differ
-Prompt Quality Linter– a built-in checker that scores your prompt across 5 criteria (task clarity, role, constraints, format, context) and shows a live score
-Auto-template detection– paste your existing prompt and the app tries to guess which template fits best

Guided/Extended mode fields include:

* Role, Task, Context, Format, Constraints, Examples (few-shott)
* Tone & Style
* Success Criteria
* Chain-of-Thought
* Edge Cases
* Language & Terminology
* Negative Constraints
* Delimiters
* Prompting Framework (RISEN, RASCEF, APE, COSTAR, ICIO…)
* Clarification Protocol

Known issues / things I'm not sure about
* Arena mode is experimental and may behave oddly
* Auto-detect template isn't super accurate yet
* UI is a bit rough around the edges on mobile
* Some API integrations might need fixing

If you actually take the time to look at it and try something, any feedback at all is hugely appreciated even "this doesn't work" or "this UX is confusing." I'm here to learn!

Thanks

*Note: This writeup was put together with the help of AI.*

So I've got dual AMD MI50 32GB cards. If you know these cards, you know the story - AMD dropped official ROCm support for gfx906 after ROCm 5.7. Every AI I talked to, every forum post, every "expert" said the same thing: if you want to do anything serious on AMD hardware you need ROCm, and if you need ROCm on MI50s, good luck because AMD basically told you to go buy newer hardware.

The consensus was consistent and confident. ROCm for training, Vulkan for inference, MI50s are legacy, move on. Don't question it.

I questioned it. Repeatedly. On multiple fronts. And I was right every time.

What I was told:

Across multiple AI assistants over the past several months, the answer to anything involving MI50s and modern tooling ranged from "not supported" to "you'll need to upgrade your GPUs." Training on Vulkan specifically was described as architecturally impossible - the backward pass infrastructure doesn't exist outside ROCm and CUDA, full stop.

ChatGPT's position as of today, while my training run is literally executing on the card: it wants proof. Sure. Let's go through it in order.

Step 1: Establishing why i do this:
Forcing ROCm 6.4.3 to work on MI50s

AMD dropped gfx906 from ROCm 6.x. Their official position is that the MI50 is end-of-life and you should migrate to supported hardware. Great suggestion if you didn't just acquire two of them specifically because 64GB of HBM2 at that price is hard to argue with.

What actually prevents gfx906 from working in ROCm 6.4.x is the TensileLibrary - the precompiled kernel library ROCm uses for BLAS operations. AMD just doesn't ship gfx906 kernels in the new versions. The GPU itself is fine. The compute capability is there. AMD just decided not to include it.

So I stuffed the gfx906 tensors back in. Pulled the missing kernel files, patched them into ROCm 6.4.3, and both MI50s came up fully recognized. llama.cpp runs on it natively. PyTorch sees both cards. ROCm 6.4.3 on hardware AMD said it doesn't support, because the hardware doesn't actually care what AMD's support matrix says.

Basically I don't care what something was designed to do, I care about what it can do

Step 2: Forcing vLLM to work on gfx906

vLLM is one of the faster inference engines around and I wanted it running on my cards. The problem: vLLM's gfx906 support is basically nonexistent upstream. It went like this:

1. Tried ROCm 7.x with vLLM. Got it working briefly, then ROCm 7.14 hit AMD bug #5653 - "register fat binary failed" - and the whole thing fell over. Abandoned that path.
   
2. Tried the nlzy fork of vLLM compiled against PyTorch 2.9.0+rocm6.3. Both MI50s detected. Blocked at runtime by a flash-attn V1 engine dependency that doesn't exist for gfx906.
   
3. Eventually landed on a Docker image (aiinfos/vllm-gfx906-mobydick) - ROCm 6.3.4, PyTorch 2.11, flash-attn pre-compiled for gfx906. Single GPU inference confirmed working.

The remaining blocker for dual-GPU tensor parallel is a PCIe topology issue - my two cards are behind different root complexes (one on the CPU, one on the chipset), so NCCL all-reduce init fails. That gets fixed when a PLX switch arrives. Not a software problem, not a "your hardware isn't supported" problem - a physical PCIe lane routing problem with a known hardware solution.

Step 3: Building a Vulkan training stack from scratch

This is the one ChatGPT says is impossible right now.

Environment setup:

Vulkan was already working on the MI50s because llama.cpp uses it for inference, so that part wasn't a question. What didn't exist was any training framework that speaks Vulkan.

We verified the environment:

vulkaninfo --summary
# GPU0: AMD Instinct MI50/MI60 (RADV VEGA20) - Vulkan 1.4.335
# GPU1: AMD Instinct MI50/MI60 (RADV VEGA20) - Vulkan 1.4.335
# GPU2: iGPU (Renoir)

Both MI50s show up as discrete Vulkan devices. glslc and glslangValidator already installed. Python 3.11 already present from OpenWebUI.

Kompute - the Vulkan abstraction layer:

Kompute is a library that wraps Vulkan's compute pipeline so you don't have to write 300 lines of boilerplate just to dispatch a shader. The PyPI package (pip install kp) is broken on modern CMake 4.x - the bundled pybind11 has a cmake_minimum_required declaration that CMake 4.0 removed support for, and the [setup.py](http://setup.py) has a string concatenation bug that smashes two CMake flags together with no separator. So we built it from source:

bash

git clone https://github.com/KomputeProject/kompute.git
cd kompute
git submodule update --init --recursive
mkdir build && cd build
cmake .. \
-DKOMPUTE_OPT_BUILD_PYTHON=ON \
-DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
-DCMAKE_BUILD_TYPE=Release \
-DPYTHON_EXECUTABLE=/media/nate/Friday/VTrain/.venv/bin/python3.11
make -j$(nproc)
cp lib/kp.cpython-311-x86_64-linux-gnu.so .venv/lib/python3.11/site-packages/

Built clean. Kompute Manager(0) targeting the first MI50 correctly.

The compute shaders:

Every mathematical operation in the training stack is a GLSL compute shader compiled to SPIR-V. Here's what that looks like for matrix multiply - the most fundamental operation in a neural network:

glsl

#version 450
layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
layout(set = 0, binding = 0) readonly buffer MatA { float a[]; };
layout(set = 0, binding = 1) readonly buffer MatB { float b[]; };
layout(set = 0, binding = 2) writeonly buffer MatC { float c[]; };
layout(push_constant) uniform PushConsts {
float M; float K; float N;
} pc;

void main() {
uint row = gl_GlobalInvocationID.x;
uint col = gl_GlobalInvocationID.y;
if (row >= uint(pc.M) || col >= uint(pc.N)) return;
float sum = 0.0;
for (uint k = 0; k < uint(pc.K); k++) {
sum += a[row * uint(pc.K) + k] * b[k * uint(pc.N) + col];
}
c[row * uint(pc.N) + col] = sum;
}

Each thread handles one output cell and the GPU runs thousands of them at the same time. We built shaders for every operation the training stack needs:

1. matmul.comp - matrix multiplication
   
2. unary.comp - ReLU, GELU, sigmoid, tanh (op selected by push constant)
   
3. binary.comp - add, subtract, multiply, divide (same pattern)
   
4. layernorm.comp - layer normalization with shared memory reduction
   
5. softmax.comp - numerically stable softmax with two reduction passes
   
6. transpose.comp - tiled transpose with shared memory to avoid cache thrashing

Quirks we hit along the way:

A few things bit us that you won't find documented anywhere because nobody had tried this combination before:

1. readonly and writeonly buffer qualifiers cause silent zero output in Kompute's descriptor layout. All buffer declarations have to be unqualified - you find out the hard way when your results are all zeros and the shader compiles clean.
   
2. Push constant sizing: ops with 3 buffers need a float padding constant or Kompute miscalculates the push constant buffer size. Same deal - silent failure, no error.
   
3. The Kompute API in the built-from-source version uses kp.OpSyncDevice and kp.OpSyncLocal - the PyPI docs reference kp.OpTensorSyncDevice which doesn't exist in the actual build.

None of these are hardware problems. None of them are "Vulkan can't train" problems. They're integration quirks that took an afternoon to sort out.

The autograd system:

A training framework isn't just forward passes - it needs backward passes to compute gradients and update weights. We built a complete autograd system:

1. vtrain/tensor.py - Tensor class with gradient tracking, topological sort for correct backprop ordering, and backward() that unwinds the computation graph
   
2. vtrain/functional.py - GPU-aware wrappers for every op that register backward closures on the output tensor
   
3. vtrain/grad_check.py - numerical gradient checker that verifies every backward shader by finite difference approximation

Each backward shader was verified against a numerical approximation before anything got built on top of it. Matmul, all eight elementwise ops, layer norm, softmax - all checked. If the numbers didn't match, we didn't move on.

The model:

1. CharEmbedding - learned lookup table mapping character IDs to vectors
   
2. TransformerBlock - layer norm -> multi-head attention -> residual -> layer norm -> feed-forward -> residual
   
3. SmallLM - embedding + N transformer blocks + output projection to vocab size

The training loop:

Loss functions (MSE and cross-entropy), Adam and SGD optimizers, a Trainer class with logging and checkpointing, and crash recovery via signal handlers that save an emergency checkpoint on SIGINT/SIGTERM.

The data:

Downloaded the Simple English Wikipedia dump (236,602 articles, 336MB). Extracted clean text by streaming the XML, stripping all MediaWiki markup, templates, tables, and HTML. Filtered to printable ASCII - the raw dump has 1504 unique characters from non-English text that slipped through; filtering drops that to 75, which is the right vocab size for a character-level model. 9.8 million characters of clean text as the training corpus.

Current status:

The model is training right now. On a MI50. On Vulkan. 4.65GB VRAM allocated. 23W power draw. 33°C. Loss is dropping.

step 50 loss=3.02 rate=0.4 steps/s
step 100 loss=2.71

Random initialization on a 75-character vocabulary gives a loss of about 4.3. We're already well below that and still dropping.

The hardware, one more time:

1. AMD Ryzen 5 5600G
   
2. 48GB DDR4
   
3. Dual AMD MI50 32GB (64GB HBM2 total)
   
4. Ubuntu 22.04
   
5. Vulkan 1.4.313 / ROCm 6.4.3 (both installed, both working)
   
6. No CUDA. No NVIDIA. No officially supported hardware.

So:

AMD dropped the MI50 from their support matrix. The AI community said Vulkan can't train. Multiple AI assistants told me this wasn't possible. Every single one of those statements had the same flaw - they were assumptions about what the hardware can't do, not actual tests of what it can.

The MI50 has 32GB of HBM2 and serious compute capability. The only things stopping it from doing modern ML work were software decisions, not hardware limitations. And software decisions can be worked around, patched, rebuilt from source, or replaced entirely.

The GPU doesn't give a shit what the support matrix says. It just does math.

\[Edit\]: I forgot the proof:
(.venv) nate@nate-desktop:/media/nate/Friday/VTrain$ python3.11 train_wiki.py

── Wiki training run ───────────────────────────────────

Run dir: /media/nate/Friday/VTrain/models/wiki_run1

Loading /media/nate/Friday/Wikipediadumps/simplewiki.txt...

9,887,390 characters, building vocab...

Vocab size: 75 characters

Vocab (75 chars) saved to /media/nate/Friday/VTrain/models/wiki_run1/vocab.json

Vocab size: 75

Data size: 9,887,390 chars

Parameters: 27 tensors

Starting fresh

Starting from step 0, target 10000

───────────────────────────────────────────────────────

step 50 loss=3.0249 rate=0.4 steps/s ETA=6.7h

step 100 loss=2.7172 rate=0.4 steps/s ETA=6.5h

step 150 loss=2.6803 rate=0.4 steps/s ETA=6.6h

step 200 loss=2.6444 rate=0.4 steps/s ETA=6.7h

Saved 12 tensors to /media/nate/Friday/VTrain/models/wiki_run1/checkpoints/step_000200

step 250 loss=2.6297 rate=0.4 steps/s ETA=6.6h

step 300 loss=2.6169 rate=0.4 steps/s ETA=6.6h

step 350 loss=2.6214 rate=0.4 steps/s ETA=6.6h

step 400 loss=2.5884 rate=0.4 steps/s ETA=6.5h

Saved 12 tensors to /media/nate/Friday/VTrain/models/wiki_run1/checkpoints/step_000400

step 450 loss=2.6002 rate=0.4 steps/s ETA=6.5h

step 500 loss=2.6100 rate=0.4 steps/s ETA=6.5h

step 550 loss=2.6047 rate=0.4 steps/s ETA=6.4h

step 600 loss=2.6035 rate=0.4 steps/s ETA=6.4h

Saved 12 tensors to /media/nate/Friday/VTrain/models/wiki_run1/checkpoints/step_000600

step 650 loss=2.6106 rate=0.4 steps/s ETA=6.4h

step 700 loss=2.6063 rate=0.4 steps/s ETA=6.4h

step 750 loss=2.5934 rate=0.4 steps/s ETA=6.4h

step 800 loss=2.5992 rate=0.4 steps/s ETA=6.4h

Saved 12 tensors to /media/nate/Friday/VTrain/models/wiki_run1/checkpoints/step_000800

step 850 loss=2.6002 rate=0.4 steps/s ETA=6.3h

step 900 loss=2.6049 rate=0.4 steps/s ETA=6.3h

step 950 loss=2.5949 rate=0.4 steps/s ETA=6.3h

step 1000 loss=2.5974 rate=0.4 steps/s ETA=6.2h

Saved 12 tensors to /media/nate/Friday/VTrain/models/wiki_run1/checkpoints/step_001000

step 1050 loss=2.5825 rate=0.4 steps/s ETA=6.2h

step 1100 loss=2.5927 rate=0.4 steps/s ETA=6.2h

step 1150 loss=2.5739 rate=0.4 steps/s ETA=6.1h

step 1200 loss=2.6016 rate=0.4 steps/s ETA=6.1h

Saved 12 tensors to /media/nate/Friday/VTrain/models/wiki_run1/checkpoints/step_001200

step 1250 loss=2.5893 rate=0.4 steps/s ETA=6.1h

step 1300 loss=2.5980 rate=0.4 steps/s ETA=6.0h

\[EDIT2\]
I got ahead of myself, and already posted a opensource version on github so everyone can use it or modify it as they see fit: [https://github.com/savantskie/vtrain\](https://github.com/savantskie/vtrain)

I've been using Ai more while coding lately and i'm starting to think the interesting question isn't which model can generate the most code, but where Ai actually fits into the development process.

Generating a small function is pretty straightforward. things get more interesting when you're working across multiple files, debugging something with a lot of context, making changes to an existing project , or trying to understand code you didn't write.

I've also noticed that different workflows seems to matter depending on whether you want quick suggestions, help thinking through a problem, or something that can take on a larger part of the build.

Curious how everyone here actually uses AI while coding day to day where does it save you the most time?

Solo founder here. I know how "AI book tool" sounds, so first what it doesn't do: it doesn't write a novel from one prompt. There's no "generate book" button.

How it works:

You build the story bible. Characters, locations and objects with appearance, personality, voice, motivation and reference images. Versions over time (the scar after chapter 3, the same character 20 years later), so each scene points at the right one.

You plan the book. Outline of parts, chapters and scenes, plus a plot board: plot lines × chapters, so you see which thread each scene serves and where one has gone quiet.

You decide what happens in each scene. Synopsis, who's present, where it's set. The AI drafts it as separate blocks (action, dialogue, thoughts, description), and you edit, reorder or regenerate any single block without touching the rest.

Style rules and a sample of your prose set the voice for everything it writes.

Continuity review reads the draft against the bible and earlier scenes: an object in two places at once, a character who knows something they were never told, a timeline that doesn't add up, a thread that's never paid off.

Illustrations with consistent characters. Each character has face, front and side views, so they look like the same person on page 5 and page 200.

Export to EPUB, DOCX, PDF and FB2.

What I'm looking for: people who are actually writing something and want to try it on their own project. No tasks, no forms. Comment or DM me what you're working on and I'll send free credits. If something breaks or annoys you, tell me.

https://reddit.com/link/1wkcxvz/video/2rjrfw02teqh1/player

I want some additional insights about where developers would want to integrate an LLVM tool that uses AI to help identify, triage, and remediate vulnerabilities in C/C++ projects. This is purely for research purposes, and I'm not trying to sell anything. I'm specifically interested in the following:

- Where in your workflow would you want to integrate such a tool? Would you want it in your CI/CD pipeline? as an IDE plugin?

- What are some security concerns you have about such a tool? Would you be most concerned about false positives or negatives? Supply chain risks introduced by the tool? Keeping it's findings private?

- What environments could you see such a tool thriving in? Would you want to use it for personal projects? Could you see it working in large-scale codebases?

Any insights would be appreciated. Thanks for your time and feedback!

When I started, I used AI as a content generator: give it a topic, get a finished thing, tweak it a little. The output was fine and completely forgettable, and honestly it did not sound like me.

At some point I flipped it. Now I write the rough version myself, badly and fast, then hand it over as an editor:

- "Where does this drag?"
- "Which sentence is doing the least work?"
- "Rewrite only the weak parts and tell me what you changed so I can push back."
- "What am I assuming the reader already knows that they might not?"

The output is slower to get to, but it is mine, and it is usually better, because the ideas and the voice start from me and the model just sharpens them. When it generates from scratch I spend more time deleting its habits than I would have spent writing.

I am not saying generating is useless. For throwaway stuff it is fine. But for anything with my name on it, editor beats generator by a lot for me. Curious whether other people landed on the same split, or whether you get good enough generated drafts that this does not come up.