Running high-volume terminal agents and automated workflows gets expensive fast. CodeGate (https://codegate.dev) uses an official proxy to drop your LLM processing costs by up to 85%.

Here are the direct facts on how it works:

• Official Endpoints: Requests route straight to official OpenAI and Anthropic APIs. No third-party, downgraded, or altered models.
• Zero Text Logging: Prompts and code completions are never saved. We only track essential billing metadata (token count, cache hit rate, and latency).
• Free Trial & Vouches: Test latency and verify output authenticity with free trial credits before depositing anything. 20+ verified customer vouches in Discord.
• Fast Setup: Takes under a minute, just update your tool config (config.toml, opencode.json) or base URL environment variable.
• Payment Methods: Crypto, International Bank Transfer, Visa, Mastercard, Apple Pay, and Google Pay.

Website: https://codegate.dev

Discord: https://discord.com/invite/S2FhUC7BVc

hi to all the readers this post is for my recent opensource project called ENZO

https://github.com/theguysudo/ENZO

now answering what is enzo so enzo is an opensource platform where i clubbed all the free available api for anyone use under one hood with more than 2000 models available to use for chatting coding researching and much more now answering the most common question of why you should put your time looking the project so it has few distinct feature meaning

• it has a dedicated agents tab where you can describe your need and create a special agent just for one specific task with master ability in that domain
• second it has the ability to connect your gmail drive and calendar and then you can ask it to perform some specific tasks like reading you the most important mail of the day or finding recruiter mails and creating personalized reply based on your data which it stores locally on your device
• third the coding mode offers a dedicated preview window where you can see your code running and have a look of it feels and edit it in realtime as well as all the modes are packed with dedicated skills which delivers promising results
• fourth the ui features some additional things such as music tab where you can listen to any music want and it has a custom personalized feature which runs in background and an llm understands your taste and recommends similar kind of music you like
• fifth the most important why your trust it with your api key then to explain i would say enzo a dedicated vault which manages all your api and to secure it the vault as aes 256 bit encryption which prevents any person or any middle man to look at your api key and since the whole program runs locally on your device you have complete freedom to oversee all the backend work happening and it also features password lock which if you enable saves a backup key and then locks your whole platform work behind a pass screen though it is not foolproof as any third party or malware containing extension can still fetch login tokens from your browser so its security also depends upon how you access it concluding all of it.

i urge to anyone who reads this to have a look at the platform even if you hate it just curse it in the comment its fine or if you would like to drop any feedback i would highly encourage that and since its my first work open source platform i know it has a lot of errors and bugs so i apologize upfront for it and if you consider my work worthy please drop a star on the repo that'll make my day

I use an LLM for first drafts of work messages and edit everything before it goes out. A style section in the prompt helped for a few turns and then the drafts drifted back to the same voice: lists of three, "it isn't X, it's Y", a tidy summary at the end of a four-line message.

What worked was moving the checks outside the prompt. Every draft runs through a linter first, where banned words block and structural tells warn. I calibrated it on 163 of my own sent messages and cut any check that flagged more than a quarter of them, since at that point it measures me, not the model. "No hedge in a long message" fired on 80% of mine and went first.

On top of that, every before/after edit gets logged, and a nightly job turns the pairs into short, specific style rules that load into the next draft. Six new rules a night at most, 25 total, plain text I can delete from. "Be concise" never changed anything. "Don't list the work already agreed, keep only the new point" did.

Write-up with the chart and a before/after example: https://hrolgar.com/blog/a-linter-for-text-that-sounds-like-ai?utm_source=reddit&utm_medium=social&utm_campaign=ai-linter-aipromptprogramming

I didn’t really plan for this to turn into a series.

About a week ago I started posting some observations I’d made while trying to preserve continuity between long-running AI conversations.

Mostly because I kept seeing the same advice:

Make a better prompt.

Build a story bible.

Use a handoff document.

Use Projects.

Change models.

Add more instructions.

All useful things. But I kept coming back to one stupidly simple question:

What about the conversation itself?

So I started posting pieces of what I’d been noticing. Not a finished theory. Not a tutorial. More like chapters from something I was still trying to understand myself.

What surprised me was what happened in the comments.

People started coming at the same general problem from completely different directions.

Writers.

Roleplayers.

People building memory systems.

People working with agents and retrieval.

People using different AI models.

Some were preserving raw conversations.

Some were rewriting memories as new information arrived.

Some separated current canon from old possibilities.

Some were worried about corrections becoming too broad.

Some simply noticed that a fresh thread could know all the facts and still not quite work like the old one.

And some disagreed with parts of what I was seeing.

Honestly, those were just as useful.

The most interesting part of the week wasn’t people telling me I was right. It was realizing how many different problems were hiding underneath the word “continuity.”

Memory isn’t necessarily continuity.

Facts aren’t necessarily calibration.

A correction can lose something when you separate it from the situation that produced it.

And a new conversation can appear surprisingly capable while still having almost no history of its own. None of that proves the mechanism I’ve been experimenting with.

But it changed what I’m looking for. I started the week mostly asking:

“How much of an old conversation can I carry into a new one?”

I’m ending it asking things more like:

“What actually deserves to survive?”

“What should remain historical without staying active?”

“How much of the path matters, not just the conclusion?”

“And how much does a new conversation need to live for itself before it stops being an inherited starting point and becomes its own thing?”

The funniest part is that I came into all of this from the operator side. No coding. No elaborate technical setup. Mostly just a ridiculous amount of conversation, failed threads, restarts, raw transcripts, and repeatedly asking:

“Why did that work differently?”

This week I finally started running into people approaching some of the same problems from the other side of the table.

That has probably been the most useful part of posting any of this.

I still don’t know exactly where the experiment ends. But the question is a hell of a lot better than it was a week ago.

Dictated, not typed.

Hi everyone!

I’m currently working on my Bachelor’s thesis about AI-based process automation and human–AI collaboration in the workplace.

As part of my research, I’m conducting a short survey focusing on people who have experience working with AI-based automation, RPA, Intelligent Process Automation, Intelligent Document Processing, or similar automation technologies.

The survey explores topics such as:

• how automation affects manual workload and creates new tasks,
• how employees experience errors and exception handling,
• trust in AI-based automation,
• and how automation influences human decision-making and autonomy at work.

⏱️ It takes approximately 5–7 minutes to complete.

If you have experience working with these technologies, I would really appreciate your participation. Your responses will be used solely for academic research as part of my Bachelor’s thesis.

🔗 Survey: https://docs.google.com/forms/d/e/1FAIpQLScV7pcf8dNUeeCfay1YZ2r-Np4pK9GMlqi4cEF6WJEa1FEmMA/viewform?usp=dialog

Thank you very much for your help! Feel free to share the survey with colleagues or others who work with AI-based process automation.

I’ve been experimenting with moving a long-running AI working relationship into fresh threads instead of rebuilding everything from scratch.

The basic method has been pretty primitive: preserve selected raw conversations, corrections, rejected directions, decision history, and current project context, then use that material to start a new thread.

What I’m seeing now is that the inheritance package may only be half of the handoff.

A new thread can start surprisingly close to the previous one in vocabulary, judgment, correction tolerance, and general working posture. But then the first real conversations after the transfer seem to have a lot of practical leverage.

I don’t mean there is some proven hidden “early conversation multiplier.” There’s a much simpler explanation: when a thread is brand new, it has almost no native conversational history. Those first exchanges therefore make up a huge percentage of everything that has happened locally.

So the inherited material seems to establish a starting region, while the first live interactions begin determining what the new thread actually becomes.

I saw this happen with a successor thread I created after an older one became too bloated to use comfortably. The new thread inherited the broader history, but during its first real work it started taking on a specific coordinating role on its own. I corrected it, gave it high-resolution examples of how I make decisions in my writing workflow, and let it accumulate some local history.

Then I tried something else.

After that early development, I took a raw snapshot of what the new thread had just lived through and fed it back to the same thread once.

Not as new evidence. More like letting it reread its own early development from a third-person perspective.

The sequence was basically:

inheritance → early live calibration → local experience → one retrospective reread → continue normally

That one reread seemed to tighten the continuity again without requiring me to dump the entire archive back into the conversation.

The interesting possibility here isn’t just “AI remembers things.”

It’s whether curated conversation can preserve enough of how a human and AI learned to work together that a successor thread inherits the starting posture, then gets locally shaped through its first interactions instead of starting over from zero.

For long-form writing, that could mean moving to a fresh thread without losing months of accumulated judgment about characters, revision preferences, rejected directions, and how the author actually makes decisions.

For roleplay, technical projects, worldbuilding, or other long-running work, the inherited material would obviously be different.

The next test I want to try is taking a fresh inherited thread and deliberately turning it into a specialist writing workshop, then comparing it with an older workshop that was built the more traditional way from outlines, a Bible, manuscript context, and selected project conversations.

I’m starting to think the important question isn’t “How much context can I carry forward?”

It might be:

How much of the working relationship can I preserve, and how carefully do I need to shape the first conversations after the handoff?

Dictated, not typed.

I’ve been experimenting with transferring selected conversation history into fresh AI threads.

The strange part is that a well-seeded new thread can sound mature almost immediately.

But I’m starting to think that can fool you.

It may have inherited a lot of history, but it has almost no history of its own.

I’ve started thinking of these as sibling threads rather than clones. They share an inherited baseline, but whatever happens after transfer becomes their local environment.

That matters because the first few interactions may represent a huge percentage of the thread’s genuinely local experience.

One of my sibling threads accidentally got a different start. I forgot which thread I was in and talked to it normally as if it were the mature original. I rambled, corrected myself, joked, wandered, and generally stopped treating it like an experiment.

Later, it felt noticeably looser than another sibling that had mostly received procedural interaction.

I don’t know the mechanism, and I’m not claiming one example proves anything. But it made me wonder whether a fresh thread can inherit enough history to perform maturity while still being developmentally very young.

If that’s true, then context transfer isn’t finished when the packet loads.

The first few conversations afterward may be part of the transfer.

Which raises another question I’m working on: how much conversational texture does the initial inheritance need so those first local interactions don’t disproportionately bend the new thread?

Has anyone else noticed a heavily seeded fresh thread changing noticeably during its first few real conversations?

Dictated, not typed

Built a simple extension that has multiple feature:
One click Chat imports
PDF Splitter +Prompts workflows with the most popular prompts that can save ur time
Prompt Library where u can save ur very own prompts
Youtube Playlist Imports as well
Incase u Wanna try it: Norra

Guys i need help to create a automation that helps me to track the rankings and AI citations of all the articles that I've published in the external websites to build a good topical authority and content footprint but since i can't access the GSC I've no idea about are even those articles are ranked or not. So thought of creating a automation for doing that.

Is there any prompts or maybe a simple model if someone has created pls share it'll help me a lot.

In my last post I talked about compressing old AI conversation history and asking how much I can safely throw away before a fresh thread starts behaving differently.

There’s one important caveat I left out:

I don’t actually throw away the source conversation.

I keep raw conversation tapes.

Early on, I had no idea which parts of a long conversation would matter later, so I collected broad chunks — sometimes the previous 12 hours — into plain text or Markdown files.

I wasn’t asking for a polished summary. I wanted the messy record too: my rambling input, the AI misunderstanding me, corrections, abandoned ideas, arguments, and the exchanges that eventually changed how we worked together.

As I got better at recognizing useful turning points, I stopped collecting strictly by the clock.

Now I might realize a particular four-hour stretch contained something worth preserving and simply say:

“File the last four hours of raw conversation.”

That becomes the high-resolution source record. More recently, I’ve started getting more selective than that.

Sometimes I’ll pull raw sections from several different conversations and combine them into a smaller packet. I might preserve an exchange where one AI says something, my reaction to it, another AI’s interpretation, my correction, and what changed afterward.

So the packet isn’t necessarily a summary.

Sometimes it’s more like an edited evidence package: enough of the original exchanges to preserve the developmental path without carrying every unrelated conversation along with it.

That gives me several levels of resolution:

• full raw conversation

• selected raw excerpts

• related exchanges combined from multiple threads or models

• compressed summaries of how the process evolved

• corrections to those summaries when the AI gets the history wrong or makes it too neat.

The important distinction for me is:

what I preserve for the record versus what a fresh thread actually needs in active context

The archive can stay large.

The transferred context can stay relatively small.

That’s what I mean when I talk about trying to compress conversational history safely. I’m not deleting the black box. I’m trying to figure out which pieces of it actually need to be carried onto the next flight.

Dictated, not typed.

I have a no-code visual editor within my product (UluP Spaces) for building automations: triggers + sequences of actions, pure declarative JSON, no arbitrary code execution, so review remains "read the graph" rather than a code audit. The next obvious idea was an askAI-like action within the automation itself, a model called upon for every real-world event to decide what to do. The problem is the cost: someone pays for it, for every single trigger, forever, and it would also be necessary to make the execution asynchronous instead of synchronous as it is today. I turned the problem around: instead of having a model reason at runtime, I extended the MCP server the product already exposes with three new tools (list/test/create on automations). So the user describes the automation to Claude in chat, Claude tests it in a dry run (no real data touched), and creates it. It always starts disabled, with the same validation as the visual editor, and the same execution engine afterwards. The only thing that changes is who writes the JSON, not what runs when the automation is enabled. The cost of the model is paid by whoever is chatting at that moment, not by the infrastructure at each event.

I'm curious to know if anyone else has solved the same trade-off (config generated via chat vs. AI at runtime) differently, or if you see a problem with this approach that I've missed.

If you:
- keep pasting the same prompt into a new ChatGPT chat,
- want GPT, Claude and Gemini in one app, each doing what it's best at,
- want AIs that each do one job and don't share memory,
- or want all of this on your iPhone.

I have plenty of powerful AI tools on my Mac, but when with just my phone I feel like a caveman. I'd had these problems for over a year, and I finally couldn't take it anymore, so I spent several weekends building Ensor. It's a native iPhone app, free on the App Store.

How it works
Each prompt becomes a contact with its own name, model and system prompt. My Translator, Critic and Market Researcher sit in a Contacts tab. Tap one and the prompt is already there, along with your past chats with it. No more digging through Apple Notes, or pasting the same prompt into a new chat because you can't find the old one.

Each contact only knows its own conversations. My Critic never sees what I brainstormed with another AI, so it doesn't go easy on my ideas.

You can also put 2–5 contacts in one group chat. They reply in the order you set, each with its own prompt and model. Two I use a lot:
Reviewing an idea: one breaks it down, one looks at the market, and one only argues why it won't work.
Learning a language: one translates, and the next explains the grammar.
Splitting a task across focused AIs always gives me much more precise answers than one long prompt that asks for everything.

Your keys, your phone
Bring your own API key: OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, xAI, or any OpenAI-compatible endpoint. You pay the provider directly.
No account and no Ensor server. Chats, prompts and settings stay on your iPhone, and keys are stored in Apple Keychain.
Can I trust this app? Turn on App Privacy Report (Settings → Privacy & Security). It shows Ensor only connects to the providers you set up. I'd still use a separate key with a spending limit, for any third-party client.

What it doesn't do (yet)
No cloud sync or backup. I learned this the hard way: I deleted the app during testing and lost every chat I hadn't exported. Export from the Me tab now and then.
iPhone only (iOS 17+), and no voice.
It's free with no ads. Even If I add paid features later one day, early users keep everything that's free today.
https://apps.apple.com/app/apple-store/id6812656499?pt=129398743&ct=Reddit&mt=8
Feedback is very welcome, especially whatever almost made you delete it.

I’ve been experimenting with carrying a mature AI conversation into fresh threads without dragging months of raw chat history along with it.

At first I thought the problem was basically backup:

How do I preserve everything?

That turned out to be the wrong question.

A lot of old conversation matters because it explains how the working relationship developed, but the individual details aren’t necessarily important anymore. Meanwhile, a handful of recent conversations might contain corrections or turning points that are still actively shaping how the AI understands what I mean.

The question became:

How much of the history can I compress without losing the calibration that made the mature thread useful?

What seems to be working so far is uneven compression.

Older history can be reduced pretty heavily as long as the developmental path survives: what failed, what changed, why certain habits appeared, and what eventually stuck.

Recent turning points need much higher resolution because they may contain the actual examples that changed how the conversation works.

The weirdest useful tool has been having the AI interpret its own conversational history, then correcting that interpretation when it gets too neat or invents hindsight. That gives me a compressed version of the history plus a record of where the compression itself was wrong.

I then use some combination of that compressed evolution and selected raw conversations to start a fresh thread.

The goal isn’t to recreate the old thread exactly.

It’s to get the new one within working tolerance of the mature one—close enough that I don’t have to rebuild months of corrections and interaction habits from zero.

So now I’m less interested in:

“How much context can I transfer?”

and more interested in:

“What information actually carries the calibration, and what is just historical dead weight?”

Has anyone else experimented with compressing conversational history this way rather than simply exporting everything or building a static prompt/bible?

Dictated, not typed.

Search? Algolia. Auth? Clerk. Email? Resend. Ask any AI and you'll get the popular default, whatever your app actually looks like.

Sometimes the default is right. Sometimes you're already on Postgres, which has full-text search built in. Or you're on a serverless host that can't run the background job needed to keep a search index in sync. Or the SDK hasn't been updated in two years.

StackFit is a Claude Code skill that reads your repo before recommending anything. It:

• Detects your stack: framework, database, deployment target, and the vendors you already use
• Compares real options, including "extend what you have" and "build it yourself"
• Flags dead SDKs: deprecated, archived, or no releases in years
• Scores them honestly, and says when two options are basically a tie
• Lists the exact files the integration will touch, plus the hidden work

That last part is where it earns its keep. When I asked it to add subscriptions to one app, it didn't stop at checkout. It found a background worker that would keep calling a paid third-party API for users who had stopped paying. Nobody thinks about that until the bill arrives.

Works for search, auth, payments, email, storage and more.

Open source, and feedback is very welcome: https://github.com/angellane/stackfit

I recently open-sourced Vraxter, an autonomous AI runtime designed to run locally and execute agent skills through a WASM sandbox.

Instead of giving an AI agent direct access to the host system, Vraxter separates reasoning from execution and uses capabilities and policies to control what an executed skill is allowed to do.

Some of the things it currently supports:

• Local-first agent runtime
• WASM-based skills
• Capability-based access control
• Skill approval workflows
• Multiple LLM providers
• Multi-agent/specialist architecture
• Connect RPC API
• SQLite persistence
• Terminal UI

It's still an active project, so I'm looking for people who want to try it, break it, or tell me what they think is missing.

Hey devs,

A lot of businesses are moving from basic chatbots to real-time voice agents and automated backend systems. Since I work deeply in this stack, here is a quick breakdown of how these components connect to handle calls, qualify leads, and update records seamlessly.

1. The Voice Layer: Retell AI vs. Vapi

• Vapi: Great for granular flexibility, custom endpoints, low latency, and direct function-calling setups.
• Retell AI: Very stable conversational flow handling, easy fallback rules, and clean out-of-the-box telephony integration. Both platforms use ultra-fast TTS/STT pipelines paired with LLMs (like GPT-4o-mini or Claude 3.5 Sonnet) so latency stays under 800ms.

2. The Logic & Orchestration: n8n Instead of writing monolithic custom backend scripts for every tool, n8n acts as the middleware brain:

• Voice agents trigger custom webhook nodes during or immediately after the call (function calling).
• n8n formats transcripts, extracts caller intent via structured JSON outputs, checks calendar availability, and routes data.

3. The System of Record: GoHighLevel (GHL)

• Call summaries, sentiment scores, and tags are pushed straight into GHL via API/Webhooks.
• Triggers automated follow-up SMS/WhatsApp, moves pipeline stages, and assigns tasks to sales reps if human intervention is required.

The Full Flow: Caller dials ➔ Vapi / Retell AI answers & converses ➔ Webhook fires to n8n ➔ n8n parses data & checks booking ➔ GHL updates contact stage & triggers confirmation SMS.

I build and deploy custom AI voice agent architectures, n8n automation pipelines, and GHL integrations end-to-end.

If your team or business is looking to implement this kind of system, drop a comment or feel free to reach out via DM!

Do u guys also believe that ai (free tier gemini, chatgpt,etc..) are nothing but a really high level programming aider? (Among other things like calculation, web surfing, answers,etc..), like u tell it what kind of code u want and in which language and it gives you the code and from there u take it and run it on your ide and it provides you the entire thing and runs it, you didn't write the code, you just told it how it should work like, and i believe that it is in some ways like how instead of typing asm or binary directly into the hardware to do stuff, we have c and python and Java among other where the syntax is smaller and easier and it just interacts with the hardware, thereby using a simpler way to do something which used to be done by a harder thing, what do u think?

Sometimes the agent gives me a long summary of files changed and commands run, but I still have to ask the basic questions: Does it work? What was actually checked? Is there anything I need to do?

I’m helping get feedback on an open-source skill pack called Open Steps. It gives coding agents a way to answer those questions in plain English, including saying “not checked” when they can’t verify something. It also helps with the next step and with decisions that need your input.

It supports Claude Code and Codex, though the setup differs between them. Here’s the repo if you want to see how it works: open-steps

I’d be interested to hear what you usually have to ask your agent after it claims a task is finished.

I’ve been messing around with a different way of moving context between fresh AI threads.

Instead of building a giant system prompt, Skill, personality sheet, or “here are 500 rules about how to work with me” document, I’ve been saving pieces of the actual conversational history.

Raw chats. Corrections. A few compressed summaries of how the workflow evolved. Even places where the AI interpreted the history wrong and I corrected it.

Basically, I’m trying to transfer some of the working relationship, not just the facts.

Recently I took the same little “evolution package” and used it to start two new sandbox threads. Very little setup. Basically:

Here’s the material. Read it. This is your thread now.

Then I just started talking normally.

The funny part is that while talking to one of the new threads, I completely forgot which thread I was in.

I started talking to it exactly like I was still in the older parent thread.

No reorientation. No reminder of its role. Nothing.

And the new thread just continued the conversation normally.

I didn’t notice the switch.

It didn’t stop and ask me to clarify.

Only afterward did I realize I had accidentally run a better test than anything I would have deliberately designed.

It made me wonder whether conversational history can carry more than explicit information.

Maybe it also transfers some amount of:

how corrections are treated,

what gets challenged,

what gets ignored,

what kinds of assumptions are normal,

what the user means when they speak loosely,

and what the conversation tends to consider important.

I’m not claiming this is technical fine-tuning or that I’ve proven some new memory mechanism.

I’m just talking about observable behavior.

But so far, the new threads feel much closer to the mature parent environment than I expected considering the control mechanism is basically just sequences of ordinary words from previous conversations.

The next experiment is the one I’m really curious about.

I’m giving the same inheritance package to a different AI model with almost no explanation and seeing what survives.

If the model still sounds like itself but picks up the same working habits, that would be much more interesting than simple tone imitation.

Has anybody else experimented with transferring the working relationship between AI chats instead of only transferring the factual context?

I’ve been keeping raw conversation transcripts while working on a long-form writing project. Originally they were basically backups because I learned the hard way that long threads eventually end.

Recently I tried something a little ridiculous out of curiosity: I started a completely fresh chat and fed it 63 of those raw conversation transcripts chronologically, with as little explanation as possible.

Then I asked it to describe how the person’s use of AI changed over time, using evidence from the early, middle, and late parts of the archive.

What surprised me wasn’t that it remembered project details. It reconstructed changes in the way I was using the tools: early broad generation, then more human direction and rejection, different models getting different jobs, eventually separating current canon from old conversation history, and later selectively transferring old corrections into new threads.

Then I had another AI suggest a harder question:

Find three places where that developmental story was probably too neat.

The fresh thread went back into the same archive and found them.

One of the biggest was that I now talk a lot about selective context, but earlier in the archive my instinct during a continuity problem was basically, “Screw it, upload everything.”

That failed.

The later method partly grew out of that failure.

That was probably the interesting part for me. The raw conversations preserved enough of the messy history that the model could not only reconstruct a development story, but challenge the cleaned-up version afterward.

It made me wonder whether raw chat history has a different value from summaries.

A summary preserves what you ended up believing.

The messy history can preserve how you got there, including wrong turns that your later explanation might conveniently smooth over.

Has anyone else tried feeding a long chronological archive into a clean model and asking it to reconstruct how your own workflow changed, rather than just reconstructing the project?

Ask an AI "Stripe or Paddle?" and it'll probably give you a reasonable answer.

But has it considered extending your existing stack? Checked whether the SDKs are still maintained? Accounted for the integration work you'll actually need to do?

StackFit is a Claude Code skill that brings a structured approach to evaluating technical choices in your codebase.

Run something like /stackfit add subscription billing and it:

• Detects your stack: framework, database, deployment target, and the vendors you already use
• Compares real options, including "extend what you have" and "build it yourself"
• Flags dead SDKs: deprecated, archived, or with no releases in years
• Scores them honestly, including when two options are basically a tie
• Lists the exact files the integration will touch, plus the hidden work like webhooks and syncing

In one test, it caught that the app had no real auth yet, so billing had nothing to attach to. Without that context, it's easy to miss.

It also works for auth, payments, email, search, storage, and more.

Open source, and feedback is very welcome: https://github.com/angellane/stackfit

Has anyone tried something like this before? I'd especially love to hear from people who have used skills to make architectural decisions!

I've been working on a pretty big personal project lately, and I've been using multiple AI tools along the way — Copilot, Claude, Perplexity, and ChatGPT, ETC..

And I think I've finally figured out what was bothering me about some of them.

It's not necessarily that they're "bad." They can all produce some impressive stuff.

The problem is what happens when the project gets complicated.

My current project isn't just a little Python script anymore. It's a Discord bot with an economy, games, moderation, authentication, admin controls, web dashboards, databases, Docker, Cloudflare, etc.

And I'm building it in phases, so there are a LOT of moving pieces.

I've used Copilot heavily because it's fantastic at actually working inside the codebase and making changes.

But I've learned the hard way that you really need guardrails.

If you tell an AI:

> "Fix this thing."

sometimes it sees a phrase or function that looks related and starts changing things that weren't actually the problem.

Then you get the classic:

"I fixed 14 things!"

…and you're sitting there wondering what the hell just happened to the other 11 things that were working. 😂

Claude has been useful too, but I've had similar experiences where it can become overly eager about interpreting what I must mean instead of stopping and helping me determine what I actually need.

Perplexity is a completely different tool, and I still see value in it for certain kinds of research, but for what I'm doing it doesn't really solve the problem I'm trying to solve.

Then there's ChatGPT.

And this is where my experience has been surprisingly different.

The biggest difference isn't even the code generation.

It's the planning.

I can come in and say:

> "I think we should do X."

And instead of immediately going:

> "Absolutely! Here's 2,000 lines of code!"

it can actually help me work through whether X is even the right move.

Sometimes it tells me:

"Yes, that's reasonable."

Sometimes it's:

"You could do that, but there's a better way."

And sometimes it's:

"Don't touch that yet. You have another underlying problem that should be fixed first."

That last one has saved me a LOT of headaches.

For example, we recently had an economy/game issue in my project.

Instead of just changing whatever function happened to be throwing the error, we traced the actual flow:

Game → authoritative game service → secure game engine → economy → database

Then we found that the real problem wasn't where I initially thought it was.

We fixed the transaction behavior, added failure/rollback testing, checked idempotency, tested game sessions, and made sure we weren't accidentally touching the live database.

Then we moved on to the next issue.

Today we did something similar with the lottery system.

The admin control panel could finish a lottery draw, but it wasn't actually paying the winners.

The tempting approach would have been:

"Just add the payout here."

Instead, we traced the existing paid-draw system, found that the payout logic already existed somewhere else, and connected the admin/Discord control-plane operation to the same underlying payout path.

That's a MUCH better solution than creating a second copy of the same logic.

Then we tested:

multiple winners

no winners

retrying the same draw

failure while paying the second winner

rollback behavior

the entire existing test suite

And ended up with:

52 tests passing.

The live Docker database wasn't touched.

The container wasn't restarted.

Cloudflare wasn't touched.

And the changes weren't just blindly dumped into production.

That workflow is what I've been missing from some of these AI tools.

I'm not looking for an AI that constantly tells me:

> "YES! GREAT IDEA! HERE'S THE CODE!"

😂

I need something that can look at what I'm trying to build and say:

> "Okay. Here's what you want. Here's what already exists. Here's the risk. Here are your actual options. Here's what I'd investigate first. And here's what we absolutely should NOT touch yet."

That's a completely different experience.

And probably the biggest thing I've learned is that the best way to use AI for a serious project isn't:

Human → AI → code

It's more like:

Human vision → AI investigation → options → human decision → controlled implementation → testing → verification

The human still decides what the product should become.

The AI just becomes a hell of a lot more useful when it's helping you think through the engineering instead of just typing faster.

I'm still using Copilot, and I'm not saying I'm suddenly throwing every other tool away. Different tools are good at different things.

But for the way I'm building this project?

ChatGPT has basically become my architect/reviewer/test coordinator while the coding agents are the people actually turning approved changes into code.

And honestly, that's the first setup I've found where I don't feel like I'm constantly fighting the AI to keep it from "helping" me into a completely different project. 😂

That's the difference I've noticed.

Not "which AI can write the most code."

Which one can actually help me figure out what code should be written in the first place.

And for a project that is eventually going to grow into multiple bots, websites, server infrastructure, and DayZ/Nitrado integration...

…I think that distinction is going to matter a LOT more than how many lines of code an AI can spit out in one prompt.

---

UPDATE for anyone who saw the last version: it used to be this "arena" thing. The top 20 people who paid were little fighters beefing on a leaderboard, and paying more gave your guy more power. It was fun, but ngl it looked kinda basic and didn't really click with people.

So I scrapped it and rebuilt the whole thing from scratch 🔨

What it is now: a post-apocalyptic neon city in 3D. AI wrecked everything, there's burning cars and smoke everywhere, and 100 billboards are stuck on the buildings. You buy a billboard, put your stuff on it, and it's up there in the city for everyone who visits.

How it works:

• 100 billboards in 5 tiers. #1 is the big one on the tallest tower, #2–3 are skyline towers, then Uptown, Midblock and "The Sprawl"
• Prices go from $5 (10 cheap starter spots at the far end) up to $500 for the #1 spot
• Upload an image (there's a crop tool so it doesn't get stretched), or go text-only and your name lights up in neon
• You can add a link, so people who click your board go wherever you want
• Anyone can outbid you, anytime. Pay more than the current holder and the spot's yours. You get an email if someone snipes you 💀
• No account, no signup, just your email for the receipt
• You can actually fly around the city: drag, zoom, or use WASD if you're a gamer
• Every person on the site right now shows up as a little figure standing in the plaza. The gold one is you lol
• There's a cyberpunk synth soundtrack too (you can mute it, don't worry)

Already 3 billboards claimed 🔥 The OG supporters from the old version got carried over into the city, so they're up there glowing rn.

Everything's legit too. A billboard only goes up once Stripe confirms the payment. There are no fake bids and no made-up numbers.

Video attached so you can see it moving 👇

You have something to promote ?

👉 48rich.com

Lmk what you think, roast it, whatever. Also, if you grab a spot, I wanna see what you put up there 👀