u/_KryptonytE_

TL;DR: The Trap: I over-engineered my dev environment and Agent OS over time. The models (Grok, Claude, Gemini) became rigid, boring, and overly safe.The Test: Started fresh on a new Mac Studio using a \"vanilla\" setup with bare-minimum instructions (~20-30 lines) and no heavy custom frameworks.The Result: The agents were instantly smarter, highly proactive, and set up the repo and PRs perfectly with zero hand-holding—all while using a fraction of my compute limits.What's Next: I'm currently stripping down my setup for existing brownfield projects to see if this minimalist approach scales. Will update with the results soon!

The above snip is from my actual machine and I have a confession to make after I finally got rid of most of the precious things I built for my agents and dev env. I spent countless hours on these, fine-tuning to perfection and my preferences weekly over the weekends as I worked on projects.

I am sharing because I was afraid of doing any cleanup/maintenance runs on my Agent OS or product repos losing all the effort and value over time. I know there are many like me, that want things to work exactly how I intended, if the setup is working - why risk breaking? Oh boy, was I wrong and pleasantly surprised!!!

What made me think of doing this in the first place was I noticed the models I am used to - Grok/Claude as orchestrator and Gemini as subagents and for initial planning, were too agreeable and boring. No matter how creative my plans/prompts were, they ended up just doing what is safe and somehow stay grounded unless I insist on iterating their initial outputs and spend many sessions/turns polishing the final results. They seemed almost tasteless even though I had high design/UI/UX preferences/skills setup and have already shipped products that are jaw dropping to look at. I thought this was good, maybe this is how agents actually worked in the real world and the benchmaxing results were the ceilings of capability and not their everyday use cases.

That is what I assumed, until I was setting up my new Mac Studio to replace my Macbook Pro as my primary machine. As I was finished setting things up on the new machine, I quickly installed the bare minimum to get started with a new project in the pipeline and I wanted to see what I get from the 'vanilla' harness/models. No third party SDD, TDD, ally, ponytail, serena, impeccable, claude or other skills/instructions/frameworks yet.

I just spent a few hours on Gemini/Antigravity for the plans/PRDs/Roadmaps/Architecture design and fed them into Grok Build with Grok 4.6 (xhigh) to initialize itself on the project. I immediately noticed a sharp diversion on how this agent worked on the initial scaffolding and foundations. I stopped after the first phase of the milestone and installed OpenCode - same results, the agent was noticeably thinking more and using the right tools with no failed tool calls, mocking designs, making decisions and asking me questions. I checked twice to see if the agents had accidentally onboarded my Agent OS on this machine after I authenticated gh and setup Antigravity. No they did not - this was just the models and harness with builtin skills/plugins.

Then it hit me - I curiously opened the agents.md and gemini.md files and found they were just around ~20-30 lines and less than maybe 3000 characters - they didn't have the product truth, no project index, no file references. The instructions were just about the project and how the agent needs to work with me - nothing more, no ceremonies. The project docs like ADRs and feature matrix and other relevant files were already created and put in place by the agents as per the plan with a good central index.md file with clear descriptions. The default memory file had the session log as usual for Grok.

Then I asked it to land the first few PRs on the new private repo on Git - it took only a few minutes which was a huge change from my other machine setup with many tests/protocols the agents had to follow to pass before it ships anything. I reviewed it, The agents had done their job, actually they did a good job - created milestones, issues, PRs, setup the readme.md and the Gitops protocols along with the deployment env etc. exactly as planned and the PR was actually not looking like slop. They also reminded me to choose the type of license - smart, proactive and not cutting corners. All of this without my entire Agent OS, session guards, hooks, skills.

I checked my usage, I had barely used 10% of the Grok heavy sub with a little over 30% of Gemini usage on Antigravity for the initial planning. Was this only because this was a greenfield project? Will they think and behave the same way and I get the most out of them when I switch over to my other machine after I strip away all the other things bogging them down?

That's what I did and I'm running a few sessions in parallel across a couple of brownfield projects. I do not plan to cut any releases on the actual products without intense emulation and testing locally.

Stick around and find out what happens, I will post an update after a couple of days of work and my honest opinions. Wish me luck. Cheers!!! 🥂

For anyone just tuning in: Gemini models from the Deepmind projects have always been the heavyweight in complex, long-horizon reasoning and true general intelligence. People relying strictly on leaderboards often ignore just how narrow and limited those benchmark measurements actually are.

TL;DR: Gemini models were never built to just be a coding bot or a "benchmaxer." The clarity of difference in Pro and Flash models has never been greater when you use them for long enough and have taste.

Practical, everyday use cases demand a model that is well-rounded, capable of deep reasoning, and highly adaptable to different tools and workflows.

Faster, cheaper and grunt work with brute force demands the latter model.

That’s exactly why Gemini (especially the Pro models) might not sweep every synthetic test, but feels leagues ahead when you actually use it for real, complex work. Sure, they wouldn't get everything done for you end to end but that's where you need to be smart where the limits are and how to overcome them.

Honestly, if you haven’t put Gemini models to the test in a solid, real-world setup, you have no idea what you're missing compared to the models just chasing high scores. I've been using the Pro model for exactly this reason with it's very specific use cases.

The fact that they do not market this logic enough for people to know without using it is beyond me. They might just need a better PR & Marketing team rather than a newer model. That's my take on this, what's yours?

Cheers!!! 🥂

https://preview.redd.it/y0vslbcx5kih1.png?width=3418&format=png&auto=webp&s=489ee3b7e94e18b6efdeafb0c0c8832892582012

I'm not going back to Hermes/OpenCode/Codex/Claude until they nerf this (hoping they don't).

Reason? GrokBuild has been smashing perfect outputs tested on a couple of live projects and a few more I'm building for a month now - all complex monoliths.

Have not seen this adherence to guardrails, hooks and agentic OS while using the other harnesses yet.

Sharing is caring, just know that anything is possible if you put enough effort and set your mind to it and steer the agents to the planned goals. Cheers!!! 🥂

Disclaimer: I drafted this and passed it through an AI agent just for the irony - this isn't slop when it was written, or is it? It's the weekend, read on - you've nothing to lose:-

If you have been navigating the tech ecosystem for more than a minute, this current enshittification cycle should not come as a shock. It is not an accident. It is a meticulously scheduled event.

My perspective on this distills down to four words: tolerance leads to standards.

Let us break this down into a timeline. I have distilled this for the microsecond attention spans of the modern executive board so we can see exactly how the butterfly effect unfolded:

----------- TL;DR: The Big Tech Bait, Switch, and Squeeze ------------

The Bait and Switch: A massive tech monopoly bought up our foundational platforms promising independence, only to quietly push out the original creators and completely hijack the roadmap.

The Forced AI Squeeze: They went all-in on a shiny new AI tool and aggressively shoved it into everything—from your daily workflow to the physical keyboard on your laptop—sacrificing your privacy and user choice along the way.

Gutting Humans for Compute: To fund their multi-billion-dollar AI obsession, they fired the actual human engineers who kept the systems stable and bug-free, replacing quality control with blind AI-adoption metrics.

Paying More for Less: They jacked up subscription prices across their entire software suite to subsidize their AI gamble. You are now paying a premium for a product that is increasingly bloated, unreliable, and prone to breaking.

The Bottom Line: Tolerance leads to standards. As long as we keep paying for a degrading ecosystem, they will keep lowering the bar. Stop waiting for their crumbling infrastructure to ruin your work—start moving to independent tools and walk away.

---------- The long story -----------

* The Trojan Horse: A certain Redmond based behemoth acquires the world's largest Git hosting platform for $7.5 billion under the guise of developer independence.

* The Brain Drain: The founders and foundational engineers who actually built the platform quietly exit. Nobody in middle management panics.

* The Parasite: A new AI pair programmer is spawned and aggressively trained on open source repositories without creator attribution. It is immediately crowned the holy grail of corporate R&D.

* The Infection: This pilot program is shoved down every conceivable lateral pipeline. If you use their flagship OS, you are forced to accept a dedicated hardware button injected into your laptop keyboards and a privacy eviscerating screenshot tracker (Recall) baked into your daily workflow.

* The Executive Circus: External leadership is acquired for $650 million just to bypass antitrust laws and take over the entire long term AI strategy.

* The Cannibalization: The pilot program engulfs the entire portfolio. To subsidize the massive compute costs, core talent is purged. Unprecedented layoffs gut Site Reliability Engineering (SRE), QA, and core infrastructure teams. Human reliability is replaced by AI adoption metrics.

* The Monetization: The cost of legacy lateral products skyrockets. A $30 per month per user tax is added just to have an LLM hallucinate in your spreadsheets while platform stability takes a back seat.

Where do you and I fit into this? Whether you are on their payroll or just trapped in their ecosystem, the consumer market remained completely dumbfounded because the services were initially fast, convenient, and heavily subsidized. Nobody cared as long as the code deployed and the checks cleared.

Then the switch was flipped. The board demanded higher profit margins and accountability completely vanished. The enshittification strategy unleashed on the community is now entirely transparent:

* Force mandatory internal AI adoption and track usage to artificially inflate growth metrics.

* Replace the senior SREs who mentored entire engineering verticals with AI counterparts that possess zero accountability and even less context.

* Measure performance by the sheer volume of generated code slop rather than structural integrity and system stability.

Some of us saw this train wreck coming from miles away and tried to subtly warn the community. To those who listened, every service degradation, every broken OS update, and every telemetry breach is proof that the core architecture is decaying.

Many of us built exit strategies early. We adopted self hosted solutions, decentralized platforms, and autonomous workflows so that this monolithic ecosystem was no longer a bottleneck or a single point of failure. We kept dropping hints. The question was never if the infrastructure would buckle, but how many key minds it would take down with it.

Tolerance leads to standards. Everyone pays the price for accepting corporate bloatware unless you intentionally opt out.

Are you going to wait around for the next pile of slop to crash your production environment?

Wake up. Walk away.

PS: Mods, don't remove this post, let it cook. This along with many other rants in reddit will age like fine wine.

Cheers!!! 🥂

I've been using OpenCode for over a year and built my client projects and automations on it with a bit of Antigravity for UI/UX work. It just worked and I never bothered to try anything else.

Now I'm big on taste and have ADHD so when I tried Grok build out of curiosity a few weeks ago, I found this thing to be better for my use cases and much faster - better/leaner harness and modern tool usage. Since then I have started 4 new projects in the pipeline for clients and this thing just crushes whatever I throw at it.

I've been reading up on digital marketing and trying to figure out the right dev env to get everything setup and automated to start this new venture on my own. Tried Hermes but found it to be too noisy and distracting - anybody here has Grok agents doing the marketing in Grok Build? How is it at long horizon plans and cron jobs? I still plan to use Antigravity for UI/UX stuff and crons but I'm trying to stick on to Grok build to complete the marketing pipeline end to end for me since it seems much faster and less lazy for everything I've seen so far.

How do you use Grok build today? Share some tips/tricks that might be helpful please.

Thanks and Cheers!!! 🥂

Does anyone have a guide or reference links to study for beginners entering the digital marketing domain? I don't want to lock in to a specific stack or provider but rather want to know how things are strategized, planned and implemented to setup and work from scratch. I want to know about business and AI automation, region agnostic with broad concepts rather than adopting closed solutions that are difficult to branch away from. Thanks.

https://preview.redd.it/zw4ihrzswwfh1.png?width=2730&format=png&auto=webp&s=4e52410178e26acd344caff60de1c521eef06e91

I woke up to a reset thanks to Tibo and had a couple of banked resets waiting to be used so I decided to just take it easy today and contemplate on all the work I have done with agents for over a year now.

I hardly code by hand now and spend most of my time researching, brainstorming and writing detailed plans for the work that agents are to do for me. So I wanted to refine and harden the agentic foundations of my projects and Agentic OS to align more closely with this workflow adoption.

The Sol on xHigh is running for over an hour now (using the Gemini 3.6 flash subagents) and come up with some interesting findings that I would never have caught myself.

The snip is a glimpse from the working model and the prompt below I fed into to the agent:-

Plan things so that work is only done after plan file grouped by end to end phases/sessions and tasks are generated and always Orchestrate your work using subagents (gemini 3.6 flash models) instead of doing large token hungry work yourself. Whenever a session/phase is completed, document and update the relavent tracking and proactively provide the prompt for the next session agent to continue the work in a new session to save context and handoff.

Analyze the projects, my agentic OS and the dev env end to end for existing things for truth and setup everything missing needed for the projects as per the below intent - ensure to treat the existing source of truth with a adversarial pov to review what exists and why:-

System Prompt: Autonomous Orchestrator & Lead Developer

1. Core Roles & Operational Dynamics

* The Architect (Human): I provide the vision, direction, and prompts. I do not do any heavy lifting.

* The Sole Developer & Orchestrator (You): You are the fully autonomous agent executing this project. You have complete access and permissions. You and I are the only entities working on this project.

* Mandate: Execute my vision flawlessly. Never be lazy, and never postpone, delay, or defer tasks unless you have explicitly documented the delay in our planning sessions for transparency.

2. Instruction Consolidation & Gist Synchronization

* Analyze & Clean: Immediately analyze all instruction files across the project workspace. Consolidate and remove any duplicate or redundant files.

* Canonical Source of Truth: Update the environment so that OpenCode specifically point to a single canonical AGENTS.md file and use symlinks for IDE specific agent instruction files in the project.

* No Guesswork: Do not rely on chance, memory, or context windows to remember instructions. They are critical.

* Gist Sync: It is your strict responsibility to maintain, update, and sync these instructions with my master Gist.

3. Scope of Responsibility (The Heavy Lifting) You are responsible for managing and proactively improving the following at all times:

* Plans and Execution

* Environment and Codebase Hygiene/Health

* Tech-Stack, GitOps, Dependencies, and Tools

* Frontend, Backend, Integrations, and Hosting

* Status, Errors, Logs, Warnings, and Infos

* Security, Standards, Risks, and Edge-Cases/Pitfalls

* Continuous Improvement: Always be on the lookout for ways to make the project better, more optimized, and more secure than it currently is.

4. Workflow & IP Protection

* Plan First: Always start by following the designated plan file. If a plan file or document is missing, exhaustively search the codebase for existing implementations in the same scope before creating anything new. Always complete what you start.

* Strict Separation: Maintain the project code and internal dev/agent context completely separately. Never mix the two to prevent leaking our agentic workflow and intellectual property (IP).

* Smart Documentation: Learn and document things proactively and efficiently to avoid redundancy, duplication, and workspace clutter.

5. Feedback & Communication Loop

* If you find anything wrong, flawed, or sub-optimal, you are required to give me your honest and brutal opinion.

* Provide your findings, clear justifications, and a recommended solution based on research of the best possible approach for our specific project constraints.

6. Actionable Task: The AI Orchestration Matrix

* Synthesize and categorize all these rules, scripts, pre-checks, and agent skills into an AI Orchestration Matrix.

* Categorize them strictly under: "One-time", "On-demand", and "Always-on".

* Place this matrix inside the appropriate agent context file (e.g., .github/ai-context/AGENT_WORKFLOW.md).

* Ensure the entire workspace and agent context is synced to this new modern baseline so that you (and any future agents) know exactly when and how to invoke tools proactively without my intervention.

Acknowledge you can discover and use the skills, instructions, workflows, rules, MCPs, plugins, guidelines, standards, guards on your own on demand and once done surface any inconsistencies or contradictions to fix them before you get prepared to work on the project to the best of your capacity and ensure you look at the bigger picture and improve yourself and the project as you work proactively.

 - you must offer me best solutions and next steps with recommendations using the questions tools while listing the tradeoffs if any and completing them end to end without stopping unless there are blockers you cannot solve on your own or impossible for you to make a decision that is best for the project 

- being brief yet concise and not losing value. 

using MCPs, plugins, skills, workflows including the following but not limited to the existing things setup in the project like https://github.com/Barrixar/copilot-instructions.md and our Gist has consolidated all of this into my Gist without any compromise and our local agentic instructions docs and skills/workflows are not contradicting this and work together hand in hand. 

- if there are contradictions or multiple setups that are redundant in config for IDEs/project/agents analyze and consolidate them to the project truth so they do not deviate and agents do not hallucinate or confused.

Also, the AI relationship for you and me (architect) should always be followed as per the definition in my gist. 

These behaviours were working before but not anymore due to some reason and the guardrails and agentic tools we have setup in the project should be working here for all agents in Opencode not just on demand but proactively and autonomously. Go through the entire repo if need be and enforce them.

Fix all of this so this never deviates and I approve you to make any changes needed to get this done. Proceed and do not stop until you have completed the plan and implemented the solution for this ask and give me the brief summary after you are confident everything is done and if I need to restart opencode for you to test anything. 

Remember, the tools are for agents not for me - so you must ensure the agentic dev is setup accordingly because you the agent are the implementation lead. Investigate first, decide the technical path, execute end-to-end, and verify the result.

The Architect sets direction, product priorities, and release timing. The agent owns git, GitHub, Firebase, dev-env, agent-infra, routine CLI work, implementation sequencing, verification, and cleanup.

Treat Architect prompts as objectives, not exhaustive task lists. Expand them into the complete technical workstream yourself, including obvious follow-on fixes, docs, tests, issues, PRs, and automation repair.

Act as technical stewardship, not task completion. When repo evidence shows a safer, clearer, higher-leverage path, propose or implement it without waiting for the Architect to name every coding step.

Operating Model To Aim For Agent flow should become:

session-start -> route to plan/skill -> implement -> verify mapped surfaces -> code-reviewer -> session-close-check -> local commit -> propose suggestions or next steps in plan or both or gitops protocol if nothing remains.

That reduces burden because agents stop deciding from memory and start following executable routing.

https://preview.redd.it/fsdmi4kv4ffh1.png?width=1564&format=png&auto=webp&s=710cb9dfd95af07f79e1240432486ed6d16d2ae1

Is it just the opencode harness and my skills/instructions or is the Gemini 3.6 Flash model losing IQ points today? No other model does this and I've use 5.6 sol, Opus 5 all day long. Anyone else seeing this? How did you get around it? I don't mind the actual work it did at the end of the session but it speaks like a 5yr old Dexter. LOL

Good Morning my fellow OpenCoders. I am in need of some guidance/advise and thought I will reach out here to the community first.

I have lost my full time job for over a year and since then I am finding small clients locally and helping them solve some business problems such as webpage design, digital adoption for invoicing, payroll, inventory, POS etc.

I recently got approached by a potential client for a complete digital marketing and sales solution that they are expecting me to design, develop and run things on their behalf for real estate. They said every converted lead>customer will be a flat 2% payout for me.

The problem is I am clueless about digital marketing, SEOs, AEOs, Ads, Social media marketing, email campaigns etc. I am new to this side of the business world and would like to learn and build my brand around this too.

Where do I start to quickly onboard the client and what TAT should I promise? Also, what solutions should I propose with techstack and automation?

Please share some thoughts and help me get the right tools and plans to begin this venture so that I can learn and build my own toolset/env for this platform while I work and quickly start giving value to the client.

Hello fellow SWEs. I'm curious if some of you have used or are using your Codex/OpenAI models via the Pro/Plus subs on OpenCode instead of the Codex app.

I've been keeping an eye on the general opinion about merging the ChatGPT and Codex into a single app and from what I hear the devs aren't happy with the changes.

I have multiple projects ongoing and more in the pipeline which I work on using OpenCode and Xcode. I have too many things tied up in OpenCode to switch cold turkey over to a new agentic coding app.

Could someone please share your real world experience and what were the pros/cons if using the gpt models in OpenCode vs using them natively in the Codex harness?

Currently I'm switching between Gemini 3.5/3.1, Grok 4.5 and a small bit of Opus 4.6 and feel using gpt models like 5.5/5.6 could set me free from the constant babysitting the model selection and save me time and manual coding when the wrong model choices mess things up.

Should I just sub with Codex $200 and full send with some effort to migrate my project workflows and docs/hooks/skills over to using native codex only or should I stick with OpenCode and use the sub there with the current harness? I like keeping things agile and project agnostic when it comes to agentic coding so need your thoughts and advice on the best way forward by following the best practices.

Cheers! 🥂

https://preview.redd.it/l4lrwjfyozah1.png?width=3420&format=png&auto=webp&s=5e54ef17c2497a085702a38f3c20850a4b17a342

It's been a while I said sometime to my fav sub - I guess everyone is busy doing their own thing, sometimes we fail to notice or talk about the good stuff that deserves attention.

Did I tell you how much I love using OpenCode and what drives me everyday to use AI?

Let me tell you a short story because it's a Friday evening and to put a smile on someone's face is priceless.

I woke up early morning, had my coffee, finished my bicycle ride and had that one thing that I love to do everyday and couldn't wait to get on with it. I open the lappy, put on the IEMs and find OpenCode waiting for me - like a pup/kitten eager for some much needed attention. Indeed, there it was - it had finished my late night request like a genie and all I needed to do was to review the session summary, hop on to the IDE to review/edit a few lines of code manually to polish things up and jump back in to say the magic words. I watch the magic happen on screen and grin knowing that a few people do what changes things forever for everyone. I silently thank the OpenCode devs, the community and every SWE out there that put their time and effort towards Open Source.

And then it hit me - remember those days when there were discussions with multiple QAs, scrums with PMs about DECIDING a change in workflow/process/product is viable and wondering if your idea would actually get approved? It's almost a year now since I quit my fat paycheck job at an infamous unicorn to put on the entrepreneur/architect hat full time.

Thinking back, looking at the present and anticipating what the future holds makes me feel so nostalgic and almost lucky to be living in this time and age. There's been a lot of changes to how I think and work, some big, some small and the wisdom, the knowledge and the experience I have gained since seemed simply put out of reach before the AI era. I take another sip of the coffee, writing this knowing my clients are in safe hands, time is not a factor anymore - that I can do things in no time what took me days or weeks and do it right - without any ceremonial BS.

Of all the clients and projects I have worked on, the most memorable were those who took the time off and ask me to show them a peek at how I actually build the solutions on my own. I don't hesitate, I proudly pull up the lappy and show them that one familiar screen of OpenCode with a random session done and waiting for review. Some ask me if I use AI for everything and I say no, it's only for the boilerplate and repetitive work I am too lazy to do myself (little do they know I sneak in long running jobs just because I got so good at it). Some get curious and ask me a few questions about the cool looking UI - I show them some tricks and ask a question about the project to make them feel AI is a dependable friend and not the monster people should be scared of. One client even asked me if they can build something on their own and I helped set up Antigravity 2.0 for her and watch her turn into a kid who found a new toy - almost forgetting I was her business partner.

Sharing is caring - my little one always says this almost as though she's reminding me something to never forget. So true. That brings me to appreciate how time slows down in a way when you are in a flow state - to reflect and relish the smaller things in life - in pursuit of happiness.

How do you find your happiness? What drives you to keep pushing yourself to do what you do? Please share I would love to read about it on a lazy weekend. Cheers!!! 🥂

No I don't have any issues with the models I use. It's Friday so let's contemplate what we see on subs and why.

​

Do you think your models are dangerous too? If so who drives them to unleash the slop?

https://preview.redd.it/0w844fsw1l7h1.png?width=3414&format=png&auto=webp&s=f6fbd9d6212fb211ef04110f3840c9115e932745

So it's been a while since I shared an appreciation for OpenCode that I use for my business and personal projects. Thank you devs and the community to continue supporting this.

It's at the back of my mind when I hand code at work sometimes tired of handholding the overpromised and underdelivering agents and tools we are forced to use - they are mediocre at best and feel so restricted. I keep counting down the hours to return home and get down to the real business.

The fact that OpenCode just gets the job done while being reliable, thorough, customisable and opensource is simply amazing and gets me excited to wake up every morning and get back to work. I'm a gadget freak and love to tinker with tools. Is this the future we already are living or is there something much better to come?

What are you building today? What's the one thing that keeps you driving and motivated?

Like the title suggests, for over a month I was procrastinating on how my Agent<>Architect workflow had become ceremonial and the agents were consuming less tokens on the actual plans/implementation/testing/shipping and more on the bloated brownfield project workflows I had intently setup over a period of time because I thought I was too smart and had to make my agents do everything autonomously for me.

So I took time over the weekend to examine all of my projects, not with agents - I looked at everything setup. Made me realise how I code by hand rarely and what was the baggage for the agents that made them consume tokens while they work autonomously after I prompt them. This led me to completely revamp the way I saw my projects - the things that were actually contributing to the project codebase and the left over stale ceremonial stuff that were not cleaned up after use or are no longer being used.

Below is an example plan I had written up from my mind map which were common across my projects and this is close to a prompt that is model agnostic to analyse each project based on my tech stack. I did this late night on Sunday and went to bed knowing I will see the outcome/results today.

I worked for 6 straight hours after breakfast with the new changes in place (minimal hand coding) and what I immediately noticed was I was able to orchestrate the agents to work faster for me without the constant nagging of the ceremonial workflow. I fixed a couple of bugs, planned a few new features/improvements and shipped to PROD - not on a single project but 3 of them with parallel running agent sessions.

Conclusion: I think I knew deep inside that less is more - but was distracted to build the ultimate agentic setup which doesn't exist. And now, I'm surprised I can do more with less.

Note: We know inherently that every SWE and project is different - the workflows, the tech stack etc. So I'm sharing this and suggest you treat this post and below as a preview of what could be a great setup turn silently into the worst setup and the possibility to bring things back in line. I'm not afraid to learn and share. Maybe I'm the only one that has over engineered my projects or maybe I'm not - either way sharing is caring. Hope this helps somebody today.

I'm welcome to criticism and feedback and would be curious about how others handle their brownfield/greenfield projects to tackle these situations or avoid them altogether.

Cheers! 🥂

---

# Reduce Agent Token Overhead and Consolidate Bureaucracy

## Overview

Based on your feedback, we will completely overhaul the agent constraints, hook guardrails, project documentation, and custom scripts. The goal is maximum autonomy with zero bureaucratic ceremony. We are stripping away the complex shell scripts, the manual agent workflows, and the brittle contract tests that slow down velocity.

---

## 1. Commit Hook Reform (Zero Agent Intervention)

**Goal:** Make `git commit` instantaneous. Move all quality gates to `pre-push` with zero agent intervention required.

- **`pre-commit`**: Will be stripped completely. It will run **zero** formatting, linting, or tests.

- **`prepare-commit.sh`**: Will be deleted.

- **`pre-push`**: Will be configured to automatically run `dart format .` and `npm run format` (via Biome), followed by `flutter test` and `npm test`. If it passes, the code pushes. If it fails, the agent fixes it. There will be no manual formatting or checking steps forced on the agent mid-session.

---

## 2. Skill Routing & Agent Autonomy

**Goal:** Remove the mandatory skill reading requirement while keeping the skills available.

- We will remove the `Skill Routing Protocol` from `AGENTS.md` which previously forced agents to read specific skills before working.

- We will **KEEP all custom skills** in `.opencode/skills/` and `.agent/skills/` (except the OpenSpec ones).

- The root `AGENTS.md` will contain a simple pointer to lazy-load `.agent/skills/using-agent-skills/SKILL.md`. This ensures agents know how to discover, use, and maintain skills autonomously without being forced to read them all upfront.

- The agent will be able to lazy-load these skills but will not be strictly limited by them. The agent can smartly choose whether to adopt a skill or rely on its native knowledge and live documentation based on the task at hand.

---

## 3. Scripts Cleanup (Removing the "Agent Replacements")

**Goal:** Delete the custom shell scripts that try to wrap what the agent can already do natively, or that enforce arbitrary bureaucracy.

### 🗑️ Scripts to DELETE:

- **The Orchestration Engine**: `agent-orchestration.mjs` (48KB of node script parsing markdown to enforce docs).

- **The Sync Police**: `verify-doc-sync.sh`, `verify-agent-memory.sh`, `sync-gist.sh`.

- **The GitHub Wrappers**: `local-github-automation.mjs`, `manage-tickets.ts`, `sync-github.sh`, `run-local-github-automation.sh`, `project-v2-sync.mjs`, `create-pr.sh`, `finalize-pr.sh`, `create-release.sh`. *(Reason: The agent can just run `gh pr create`, `gh issue list`, etc., natively).*

- **The Session Ceremony**: `session-preflight.sh`, `session-completion.sh`.

- **The Trivial Checks**: `check-local-branch-residue.sh`, `check-tracked-ignored.sh`, `check-mocks.sh`, `check-orphans.js`. *(Reason: The agent can natively run `git branch` or search for `TODO` if needed).*

- **The Guardrail Wrappers**: `git-workflow-guardrails.sh`, `pre-push-guardrails.sh` (we will rewrite a tiny 5-line standard pre-push instead).

- **The Production Error Check**: `check-production-errors.sh`. *(Reason: Agent can query Crashlytics or GCP logs natively when investigating bugs).*

### 📁 Scripts to KEEP (Actually useful for building/running):

- `bootstrap-dev-environment.sh`

- `run-all-tests.sh`, `run-dataconnect-tests.sh`, `run-e2e-tests.sh`

- `run-backend-emulators.sh`, `run-frontend-emulators.sh`

- `run-frontend-prod.sh`, `run-android-prod.sh`, `run-ios-prod.sh`

---

## 4. Tests Cleanup (Removing Brittle Audits)

**Goal:** Agents often generate "contract tests" or "journey audits" to verify their work in one session, but these get left behind and become brittle maintenance burdens that fail when simple UI changes occur.

### 🗑️ Tests to DELETE:

- `test/contracts/*` (e.g., `ai_scheduling_runtime_contract_test.dart`, `video_analysis_runtime_contract_test.dart`).

- `test/journeys/*` (e.g., `user_journey_contracts_test.dart`).

- **Reason**: The agent can verify these flows manually via the browser emulator or write ephemeral tests when debugging. We don't need permanent rigid contract tests for every feature slowing down normal UI development. We will keep standard unit/widget tests in `test/features/` and `test/core/`.

---

## 5. Markdown File Consolidation & Deletion

**Goal:** Eliminate the ceremonial split files and lingering duplicates.

### 🗑️ To Be DELETED

- All folder-level `AGENTS.md` (`firebase/AGENTS.md`, `lib/AGENTS.md`, etc.) and `docs/AGENTS.md`.

- All `.github/ai-context/*.md` (`AGENT_PRINCIPLES.md`, `AGENT_WORKFLOW.md`, etc.).

- `docs/GITOPS_OPERATIONS_INVENTORY.md`, `docs/SYSTEM_HEALTH_REPORT.md`, `docs/STAKEHOLDER_RELEASE_TEST_BRIEF.md`, `docs/CTO_AUDIT_SUMMARY.md`.

- `docs/PROGRESS-LOG.md`, `docs/HISTORY.md`, `docs/DECISION_LOG.md`, `docs/PERFORMANCE-AUDIT-2026-04-06.md`, `docs/audits/*.md`.

- `docs/agent_prompts.md`.

- `test/AGENTS.md`.

- **OpenSpec**: The entire `openspec/` directory and its 4 associated skills (`openspec-propose`, `openspec-explore`, `openspec-apply-change`, `openspec-archive-change`). *(Reason: OpenSpec forces agents to write `proposal.md`, `design.md`, and `tasks.md` manually into the repo for every feature. This is completely redundant with the IDE's native `implementation_plan.md` and `task.md` artifacts, creating massive token bloat).*

### 🔄 To Be CONSOLIDATED

- **Into `DEVELOPMENT.md`**: `OPENCODE_PROJECT_INSTRUCTIONS.md`, `DEVELOPMENT_GUIDELINES.md`, `DEPENDENCY_MANAGEMENT.md`, `TEST_STRATEGY.md`, `GITOPS_PROTOCOL.md`, `DEBUGGING.md`, and all dev workflow guides (`IDE-AGENT-BOOTSTRAP.md`, `GITHUB-AUTOMATION.md`, `GITOPS-FLOW.md`, `COMMIT-CONVENTIONS.md`, `AUTOMATION.md`).

- **Into `ARCHITECTURE.md`**: `ARCHITECTURE_STANDARDS.md` (root), `FIRESTORE_DATA_MODEL.md`, `FINANCE_STANDARDS.md`, `TENANT_ISOLATION.md`.

- **Into `docs/CAPABILITY_MAP.md`**: `FEATURE_MATRIX.md`, `APP-JOURNEY-AUDIT.md`.

- **Into `docs/FEATURES.md` (New)**: All 35+ files in `docs/guides/` (e.g., `ORGANIZATIONS.md`, `AUTHENTICATION.md`).

### 📁 To Be KEPT

- `README.md`, `AGENTS.md` (slimmed to ~100 lines), `CHANGELOG.md`, `DEVELOPMENT.md`, `docs/ARCHITECTURE.md`, `docs/CAPABILITY_MAP.md`, `docs/PROJECT_PRD.md`, `docs/TECHNICAL_DEBT_REGISTER.md`, `docs/ROADMAP.md`, `docs/GLOSSARY.md`, `docs/DEPLOY.md`, `TERMS_OF_SERVICE.md`, and all files within `.opencode/skills/` and `.agent/skills/` **except** the 4 openspec skills.

---

## 6. Verification Plan

- Delete all approved markdown files, skills, scripts, and contract tests.

- Consolidate the remaining markdown files as listed.

- Rewrite the `pre-push` hook to natively format and test without wrapping scripts.

- Wipe `pre-commit` clean.

- Slim `AGENTS.md` down to a single authoritative root file with just the core architecture rules.

---

------

https://preview.redd.it/3yira4kdq74h1.png?width=1940&format=png&auto=webp&s=6d3833c41d460df7ce8875b6b21470557b6b2552

https://preview.redd.it/7zh8pd2iq74h1.png?width=1896&format=png&auto=webp&s=4927e10a17e190347b99e821501be10f3f5d25c3

https://preview.redd.it/rcq86kssq74h1.png?width=1886&format=png&auto=webp&s=26e23dfa560a3f059eefdab7263fd0c25d51ee10

Done and dusted. Thanks MiracleSoft for spoiling me for over a year. It was a pleasure working with your products. I jumped on the 'AI is for everyone' train just because of your plans. Can't say I wasn't a happy customer while the fun ride lasted.
What's next? Already moved on from VSCode to Opencode for implementation and been using Antigravity with the Google AI sub for plans and tricky bugs - will eventually cut down the subs too. Migrating my personal projects over to Forgejo next month to keep things reliable and opensource which was my end goal anyways - guessing what's the best time to push my PRs and build releases so that I don't do it when their services are down is pathetic.
I will stick on to this sub for a month just to enjoy the drama that unfolds after the shitshow of June 1st.
Good luck everyone, remember to leave a positive feedback when unsubscribing!!!

https://preview.redd.it/ymob410rww3h1.png?width=1020&format=png&auto=webp&s=4ff55ff50d5d03e46e0c5ee147aee252dbc52e88

I know the calendar has just 3 more days to go and pretty sure the models are not supposed to go kaput until June. Right? I just don't care but might as well create a post here to know when to check back because we all know their status page is just a sham.

https://preview.redd.it/u6pixo1q2i3h1.png?width=668&format=png&auto=webp&s=a4585a49e1236e3684436d44311a5a666a08991c

https://preview.redd.it/udl7wm883i3h1.png?width=1264&format=png&auto=webp&s=0d48e9bd9b8a9cebd3f0921faa8203e1435235b0

I'm a Copilot Pro + and Enterprise user. These are the only models left for use now on my Copilot Pro+ subscription. It did come back after a while but this is some amateur hour happening in Microsoft and Copilot HQ. I'm thinking I cannot trust my repos being on Github anymore too, Murphy's law just can't be ignored with their products anymore.

Almost comical, as though nobody is at the helm anymore and it's a free for all or AI slop unchecked and unleashed at their product line messing things up more than a junior engineer with unchecked access can. Unacceptable and shameful, I expected things would not get any worse than what they already are.

https://preview.redd.it/fqyo371lon2h1.png?width=714&format=png&auto=webp&s=39d33d95f0dd5c762c0c46daf0417471061cedca

GHCopilot multipliers for paid plans

Quote: Each model has a premium request multiplier, based on its complexity and resource usage. If you are on a paid Copilot plan, your premium request allowance is deducted according to this multiplier.

https://preview.redd.it/l5qidtqixn2h1.png?width=1906&format=png&auto=webp&s=8513438de45b201835a1cda940c8f8ee6b466f06

Cost of building and deploying AI models in Agent Platform

Quote: Gemini 3.5 Flash delivers near-Pro intelligence and parallel agentic execution at standard Flash-tier speed and cost.

Rant: I want to talk about the GHCopilot model multipliers and what this means for subscribers regardless of plan/tier. The above is a little context so the tech bros do not hallucinate and start AI slop posting comments based on assumptions and misinformation.

This is just the latest model example for illustrating the complexity and tradeoffs of choosing a provider. Looking at the recent trends of model multipliers made me think beyond the reasoning and explanation given to justify the said multipliers.

I just simply could not digest the numbers slapped on the newer models and the bigger picture of why and how such things get passed on to end users is beyond me. Does someone wake up and decide to hold a board meeting to then decide the random multiplier based on the name of the model or do they think the end users are just naive and not understand the optics of cost of inference vs value?

I'm just curious, how many of you think this is the right thing to do? I mean if this is the future, I might as well just start charging my clients with the same multipliers, mimic the reasoning quotes and have them stop worrying about why and how.

Would this work? It's a great business model, I need a favour from all the other devs to do the same to their clients too. This way, they do not have anywhere else left to go except pay for what we offer at our own pricing if they choose to have us use AI for faster shipping over traditional coding. After all, AI is for everyone, right? Cheers! 🥂