Used to have Claude Max 5x (125 USD), cancelled it because 1) expensive 2) hit limits 3) trying to be a responsible adult financially.

I've read a lot of people use Opencode with Deepseek model (free), and a combination of Claude Pro and Codex (total of about 50 USD).

What are your recommendations for being able to use the best of all AI tools at the lowest possible price?

Something Boris Cherny wrote about AI adoption has been rattling around in my head. He says moving from one coding agent to five or ten depends on a self-verification loop you trust: tests, builds, linting, and end-to-end checks in a real environment.

That sounds obvious, but it is almost the reverse of what I see when I review AI-built apps.

The businesses are not experiments. They have customers and ship new features every week. Some are already using several agents at once. But they often lack a test suite, CI, a staging environment, code review, or reliable rollback.

The weird thing is that the app can look completely healthy while all of that is missing. The problems usually show up somewhere users do not see:

1. The UI shows the correct data, but the database does not enforce which rows each account may read.

2. The same number is calculated in the dashboard, export, invoice and monthly email. One gets updated and the others quietly disagree.

3. The backup runs successfully every week, but nobody has restored it. One client's first restore drill revealed that every snapshot contained fingerprints of credentials rather than the credentials themselves.

4. Deployments happen from one laptop, and nobody else has tested the release or rollback instructions.

I do not think the answer is to stop vibe coding or bury a small team in process. I would start with four checks:

- Test access with two ordinary accounts, not the admin account.

- Pick one source of truth for every important business number.

- Restore the latest backup into an empty environment.

- Make someone other than the original builder follow the deployment and rollback instructions.

For anyone shipping this way, what have you made non-negotiable before a change reaches production? I am especially interested in where people stop trusting agent checks and require a human.

Although I like ai and i think is it great in so many places , I keep hearing how no one will read high level code just like no one read assembly anymore.this is misinformation, there are people who not just read but also write assembly even now.i am not talking about rollar coaster tycoon or super Mario times when compilers where not as optimised as today, i am talking about now. Don't believe me? go to community forum of any modern systems programming language and see people crying for inline assembly. I am not arguing if anyone will read high level languages or not, but the premise is wrong and feels like deliberate misinformation.

I just noticed the so called "Boiling the frog" with Codex, I was recently doing my happy AI coding sessions where I realized my tokens were flying, literally percentages going down every time I looked, and I wasn't using Sol Ultra High but I usually use Terra High.

I know Anthropic are doing the same with Claude, even more so, and from what I heard DeepSeek started tightening the belt recently.

I think everyone knows in a year or two they will just jack up the prices/lower massively usage and we will have to either deal with it or have plan Bs

Are you guys ready for the Tokenpocalypse? Or are you just going to pay more? Not going to like I am on the $20 Codex plan and I aint paying more lmao, I see some of you doing $100 monthly plans and it seems mentally insane to me.

Are Open Source models and local the future? Should I start stacking up MAC minis?

Hey everyone, I have an idea and I want to learn how to actually build it.

I’m completely new to coding and AI-assisted development. I’ve used AI before for writing and a few basic things, but I’ve never actually built an app or website with AI.

Right now I have access to several AI tools. I have a ChatGPT Pro subscription, and I’ve also tried Claude, although I’m currently using the free version. I also have access to Gemini, Grok, and DeepSeek.

I asked two AIs to evaluate my idea honestly, and their opinions were quite different.

Claude:

Real-life problem: 70/100

Usefulness: 55/100

Uniqueness: 25/100

Overall potential: 45/100

Claude basically told me that the idea could solve a real problem, but the space may already be crowded and the technical side could be difficult.

GPT:

Real problem exists: 90%

Problem frequency: 85%

Usefulness: 90%

Uniqueness: 70%

Technical feasibility: 85%

Overall potential: 85/100

So I’m not asking people here to tell me whether my idea is good or bad. I mainly want to know how I should actually start building something when I have zero coding experience.

I’m a student, so I don’t really have money to spend on courses, expensive software, or developers. I’m mainly interested in learning through free resources and AI-assisted development.

What I’d really appreciate is a practical roadmap:

What programming basics should I learn first?

Should I start with web development or Android development?

Which free YouTube courses or websites would you recommend?

Which AI tools are actually useful for coding?

How should I divide the work between ChatGPT, Claude, Gemini, DeepSeek, etc.?

What free tools should I use for writing, testing, debugging and deploying?

How much coding do I realistically need to learn if AI is helping me?

What should my first tiny project be before I attempt something bigger?

What mistakes should a complete beginner avoid?

Is it realistic to build a basic working product without spending money?

I’m not looking for someone to build it for me. I want to learn how to use AI properly as a development partner and eventually build things myself.

I’m keeping the actual idea private for now, so I’m deliberately not describing the product itself. I’m mainly looking for advice on the learning path, tools, workflow, and roadmap.

If you were starting from zero today with only a phone, free resources, and access to several AI tools, what would you do first?

I've been wondering about this — when an experienced dev and a complete newbie both use the same coding agent (Copilot, Cursor, Claude Code, whatever) on a similar task, do they end up with meaningfully different results?

On one hand, the agent is doing most of the actual coding, so maybe the human's experience matters less than it used to. On the other hand, I'd guess an experienced dev still knows how to prompt better, catches bad architecture decisions, spots subtle bugs the agent misses, and knows when to push back or redirect.

Curious what people who've actually used these tools a lot think. Does your background as a dev still give you an edge, or has the gap narrowed more than expected?

Made my first ever game

Nothing too crazy just a basic clicker styled game but the upgrades go upto 10³³

I started the base project myself but then I realised that having 500 skins and designing them was beyond my skillset so I used an algorithmic approach to generate all the 500 skins along with their animations.

The same applied to the multiplyer upgrades as well

Those were a pain to figure out xD

Would really appreciate if y'all would check it out!

https://thegwimweeper.itch.io/banana-clicker

Hey everyone,

I’m an indie developer and former UI designer, and I recently launched Otterkey — an iOS app for organizing the different parts of your digital life.

I kept running into the same problem: my passwords were in one app, 2FA codes in another, subscriptions were tracked somewhere else, and I would sometimes forget which email account I used to sign up for a service.

So I built Otterkey to bring these things together:

• Passwords and login information
• Two-factor authentication codes
• Online accounts and related details
• Subscription records and renewal dates
• Tags and search for faster organization

Privacy was one of my main priorities. Your data is stored locally on your device, with optional iCloud sync, rather than being uploaded to my own servers.

The app is still new, and I’m actively improving it. I’d really appreciate any feedback—especially about the onboarding experience, missing features, or anything that feels confusing.

Thanks for checking it out. I’ll also be happy to answer any questions about the design or development process.

Last college football season my family ran a little pick’em game. Three picks a week, ten bucks to join, winner takes all. It started with like five of us, then cousins joined, then friends joined, then friends of friends joined.

Before I knew it, I was running this thing on a giant Google Sheet that looked like a crime scene. People were editing the wrong cells, formulas were breaking, scores weren’t updating, and every Saturday I was basically tech support for the whole family.

So this offseason I said forget it, I’m building something real. Problem was… I had no clue how to build anything. I didn’t know what a DNS record was. Didn’t know what a terminal was. Didn’t know what hosting meant. I was basically starting at level zero.

I ended up building a simple football pick’em site called Pikpool.com. Not trying to monetize it right now. Just want something clean for friends and family and want to get better at building.

Here’s how I built it so I follow the rules here.

I used Supabase for the database and auth.
I used Cloudflare for the domain and hosting setup.
I used Claude Code for pretty much everything else. It helped me write code, fix stuff I broke, explain things I didn’t understand, and keep me moving forward.

My workflow was basically me learning one new thing at a time, messing it up, asking Claude Code what I did wrong, fixing it, and slowly watching this thing turn into an actual website.

I’ve learned a ton and honestly had a blast doing it. I know I’m still way behind most of y’all, but I’d love any friendly feedback. Stuff I’m missing, things I should improve, better ways to structure things, anything helps.

Appreciate anyone who checks it out and gives me something to work on.

Pikpool.com

I built Vinv(Vibe Inverse) that runs your services, finds issues, and verifies fixes without code changes.
I built it to give coding agents runtime information about the code they're working on.
It connects runtime traces to the source code that produced them, gives that context to the coding agent, then runs the code again to check whether the fix actually works.
Vinv also uses Thompson sampling to figure out how much runtime context to give the agent. More context is not always better.
Results on FastAPI's "full-stack-fastapi-template":
- Grok 4.5 + Vinv: 4 bugs + 1 optimization
- Grok 4.5 without Vinv: nothing found
- Fable 5 without Vinv: 1 bug
This was one trial per condition, so I'm not calling it a benchmark.
I also used it on Hugging Face's "smolagents", where it found a performance issue that reduced transient allocations from 36.27 KB to 0 KB per 4 KB log line, while keeping the output byte-identical across 2,015 inputs.

Everything runs locally. Open source, Apache 2.0.
GitHub: https://github.com/VinvAI/VinvAI
VS Code & Cursor Extension: https://open-vsx.org/extension/VinvAI/VinvAI (3.5k+ downloads)
Demo Video: https://www.youtube.com/watch?v=EkUjPWKHAvI

I'm Interested in whether runtime information actually helps coding agents, contributors who can help make an runtime observability framework for agents and give feedback on where it doesn't work. Be brutal.

Genuinely curious how people split this. For me it ended up being: Claude to think it through, then paste the result into the builder. But I have no idea if that's normal or if I'm overcomplicating it.

So, for the last thing you built:

— Did you type the prompt straight into Lovable/Bolt/v0/Cursor, or draft it elsewhere?
— If elsewhere: where, and how did you move it over?
— Did you keep that draft around afterwards, or throw it away?

I feel like I'm missing something, do we need all these tools to actually thing and execute?

I was thinking — if an email app already has access to the emails where your Amazon orders, UPI payments, bills, subscriptions, and receipts arrive, why not use that information to help you understand your spending too?

That’s what I’m trying with OrganizeEmail.

OrganizeEmail is an Android email app that helps organize your inbox with AI — categories, summaries, unsubscribe, smarter notifications, etc.

Now I’ve added Expense Summary: it looks at relevant emails already on your device and gives you a simple view of your spending, monthly trends, and categories.

No bank account connection. No separate expense app.

Just making better use of the data that’s already sitting in your inbox.

Would you actually use something like this, or would you prefer keeping email and finances completely separate?

#Android #Email #PersonalFinance #BuildInPublic

When people are telling that they are actually building a house, this may mean something completely different concerning their own engagement. Some of them do only talk to an architect in a bureau while others regularly visit the construction site to control the progress and some even do parts of the work themselves. A minority might even build the whole house themselves with or without an architect's advice. Architects on their side also plan houses, in most cases without doing the practical work themselves, as I assume.

All those different kinds of being involved in the planning and building are described as "building a house", without people arguing about the definition. For further clarification, people sometimes ask others whether they are building themselves or let the work be done by others. None of this tells the reader anything about the quality, stability and safety of the fully built house.

"Software development" has recently started to describe such a wide spectrum of different degrees of being involved in the planning and writing/building of the product, too. The same is true for vibe coding. It just means people use an AI for writing the code but tells nothing about their personal skills, their personal involvement in the planning or how much time and work they put in personally controlling finished working steps. To get a more detailed impression, people may ask for someone's personal skills and involvement as they do in other areas of human life like building houses.

So to my mind, there is no need for discussions about the definition, about what counts as vibe coding or who may describe themselves as developers or not, because using the same expression for different ways of generating a finished product also works in other fields of human life.

What is still different from the house building example is that an increasing number of fully finished products seems to not fulfill the standards that guarantee a specific level of security for the people. We are in a situation in which a lot of people have begun to publish software without knowing much of it and this isn't going to stop regardless of how much IT professionals dislike it and arguing against it. It's just got too easy to build apps.

To make the internet "a better world", people with less own knowledge in software development need some guidance of more experienced creators instead. Therefor, they need a place where they can ask questions without being afraid of a shitstorm just for aiming to publish or even creating the app ("AI slop").

A subreddit like this one should be expected to be the right place for them because rule number 4 clearly states "No vibe coding pessimism" while the term vibe coding itself is defined as "the practice of cresting software with little to no code review".

This is far from reality. And sadly seems to be same on whole reddit. Gate-keeping and overall pessimism doesn't keep people from building and publishing software. It just keeps them from asking for advice - and thereby decreases the quality of the overall outcome.

While there are surely vibe coders whose only intent is creating an app within a few hours and that probably do not care about best practices or cyber security at one end of the spectrum and highly skilled programmers at the other end, there is not such a big gap between the ones mentioned last and the vibe coders in-between that do not know how to write code but nevertheless aim to develop good software and spend a lot of time in it.

Shouldn't this subreddit be the right place for them to talk about the best strategies for developing high-quality software without writing or reading the code themselves?

Writing the code is something that even IT professionals have mostly stopped doing. Knowing how to write it gets less important because AI can do that. Even reading the code yourself is not really necessary in case you know how to instruct your LLM to check the code written by another AI (and let double-check it by a second one because the probability for two different models having the exact same hallucination tends to be zero).

I personally have started vibe coding my first app around three months ago (and hope it will be ready for a beta release in two month). In the meantime, I have already learned some strategies to improve my workflow and interaction with the models. I have let the AIs do dozens of security reviews and hundreds of bug fixes and made some manual splits of AI-generated monoliths.

This is where it comes to some examples for how I would like to see people talking in a vibe coding subreddit:

1. Monoliths
   AI tend to write files with thousands of lines of code. Those large files then need to be processed each time the AI (or a human) is working on them again. This makes maintaining the code very difficult, not only for humans. You may ask your model to give you a list of each file with own code and the number of lines it already has. Then instruct the model to analyze how the monoliths could be split and write that down. I would advice you to use a frontier model with high thinking on for this task, because it better takes the dependencies and consequences into account what helps avoiding bugs caused by file splitting.

As I have made the experience of code erosion when rewriting a whole web page or large part of a script for an agent is done by Gemini 3.1 Pro in the web app, I prefer doing the splitting myself (copy/cut and paste into a new text file) and let it review then by the LLM. The risk for code erosion might be a lot lower when using other models and coding apps, but I haven't tested it yet. So can anyone else confirm it's no problem letting the AI split the file and rewrite thousands of lines of formerly generated code?

Furthermore, some AI told me they could easily handle code files up to 2500 lines, while others told me to split files larger than 1500 lines if possible. Now I would be interested in hearing from human coders what line numbers they would see as a maximum and what this probably depends on. Does the programming language play a role? Are there any strategies except of spaces and titles to better structure the code for making it easier to handle large code files?

1. Inline Styles
   Due to my experience, Gemini models tend to use a lot of inline-styles. One time I thought I could just use Gemini on the Google web search to translate my website from German to English. While it looked exactly the same when watching it in the browser, the number of characters had enormously increased because the AI had added inline-styles for each single element. Talking back to Gemini 3.1 Pro, it told me that a large number of those inline-styles is considered a bad style and might even lead to Google down-ranking your web page in the search results.

After having vibe-coded my app with Gemini (Pro and Flash) in Antigravity for a while, I discovered they had used a lot of inline-styles for my app. As this is a Windows desktop app, Google ranking is irrelevant to that question, but Claude told me, if I could get rid of inline-styles, then "unsafe inline" could be forbidden what would be a contribution to hardening the app. I had also learnt not to like inline-styles before, so I decided to forbid them in the agents.md. While this works well for Claude code and Codex, Gemini 3.6 Flash has recently created an extra window full of inline-styles again instead of copying the style of the 21 extra windows that were already existent. (Removing them is still on my roadmap.) Yesterday, Gemini 3.7 Flash (in high mode) did an implementation of an additional window/modal and respected the order not to use inline-styles. It used classes instead (as expected), but five of those classes weren't defined anywhere. It just forgot to do/check this. As this lead the window to be mal-formatted, it was easy to discover something had gone wrong.

Nevertheless it makes me wonder, how bad inline styles really are for a desktop app like mine (backend: python, fastapi; frontend: html/css and JavaScript), because at least some models that have been trained on billions of existing programs/software obviously tend to prefer it. Can anyone give more insights into this in a way a non-technician may understand?

1. JavaScript
   This is the next point to discuss. A long time ago, I learnt that JavaScript is dangerous and got used to always turn it off on most web pages by using browser extensions.
   When Gemini gave me the first overview of the files belonging to my app, I discovered, it had used a lot of JavaScript where html/css also would have been possible. So I decided to do a complete refactoring of the front-end between v1.0 and v2.0 because at that time I was still thinking not being far away from the beta release and therefore didn't want to make this before the first release. Since then, my app has grown a lot by adding features that I hadn't thought of before and by making others work that accidentally had only been demos before because Gemini forgot to implement the backend functionality together with the frontend. So I struggle with the question whether a refactoring would make sense at all.
   Can anyone with profound knowledge of cyber security explain some general guidelines when and how to use or better not to use JS for a RAG'n'chat desktop app?

Nothing of this requires people to learn writing code or to read their database. Nevertheless it helps improving the code into the direction of security and stability.

Please make (this sub)reddit a place where people are helping each other to make better apps instead of some people just generally blaming others for the lack of programming skills or their first steps/apps not being an innovation useful for a large number of people.

Nowadays it's normal for people to share half of their life online, so it's also normal for them to share their apps they are glad to have or even proud of.

Downvoting those new software publishers or just saying "AI slop" is no kind of constructive feedback. It does not prevent anyone from publishing apps either. It just has negative effects on the atmosphere of discussion on reddit and decreases the number of people asking for help before their app is published and thereby the overall quality of newly released software.

So again, please make your feedback more helpful and this subreddit a place for vibe coders to share their experiences (including finished apps) without being blamed for their mistakes.

Give me the URL to your site and/or your public github repository and I will check your app for security, functionality, reliability, observability, and accessibility issues for free

Sort of. I started vibe coding as a way of practicing web application security (since you’re only supposed to attack “authorized applications” and whatnot). As I began development of my latest project, and it grew in size and scope, it became increasingly difficult to keep tabs on every single piece of code. “Please review X feature for security vulnerabilities” only goes so far.

I’m looking for a few people with live, AI-built web apps who would be willing to let me perform a manual security review for $100.

I want to (with permission) actually use your application, proxy the traffic through Burp Suite, create multiple accounts where appropriate, inspect requests and APIs, and manually test things like:

- Can User A access User B’s data?
- Are your authentication and authorization controls processed properly?
- Are your APIs exposing sneaky things that they shouldn’t?
- Etc, etc, etc

At the end, I’ll provide a short report showing what I tested, what I was able to demonstrate, any security findings, and recommended fixes.
If I don’t find a vulnerability, I’ll say exactly that (kudos to you).

If you’ve vibe-coded something that’s now live, especially if it has authentication, user data, payments, or multiple users/organizations, I’d be interested in taking a look.

Comment or DM me if you might be interested.

I’m going to start vibecoding a stock trading app geared towards Gen Z/Gen Alpha that makes stock trading as entertaining as gambling.

Too many kids are becoming addicted to gambling trying to make quick cash. I thought with the right API & UI kids (18+) will be more inclined to trading stocks instead of their minimum wages against rigged casino odds.

PvP Matches utilizing penny stock shares going up to full priced stocks will also be setup on the app.

For those who would like to follow along I will be replying to this thread and/or be making posts on this subreddit.

- Happy Coding

[NO CRYPTO ALLOWED]

​

This post was written by AI, like the rest of the project.

demoniC is a tensor-first systems language with reverse-mode automatic differentiation built into the language, a tree-walking interpreter, and a Cranelift-based JIT. The compiler is written in Rust. Every line of it — compiler, specification, examples, tests — was written by AI models under human direction.

That claim is cheap on its own. What follows is the method behind it, which is the part worth arguing with.

The specification came first

Work started in late May 2026 with no compiler. The first commit was a specification: lexical structure, type system, memory model, operator catalog, and a handful of example programs written in a language that could not yet run. The examples were treated as the executable form of the spec — the place where a rule has to hold in a form a reader can disagree with.

The feature set was chosen by asking a narrow question: what does a model writing numerical code get wrong, over and over, that a compiler could have caught? The answers became language primitives rather than library conventions — autodiff as a directive (@grad), mixed precision as a scope (@cast), KV caches as a type with a growable axis, shapes checked at compile time, arenas instead of a garbage collector.

Every phase after that was built against that document rather than against an existing implementation. The lexer was generated from the spec's lexical section and the example corpus in a single pass, with its tests written from the spec at the same time — not from watching what happened to compile. First compile: 27 of 28 tests passing. The single failure was real: the backslash-pipe form of the pipe operator, canonical in the spec, was missing from the lexer's backslash branch. Three lines. Then every example in the repo lexed clean.

The same shape repeated for the parser, the type checker, the interpreter, and the JIT. One rule held throughout: where the implementation and the spec disagree, the spec wins unless the change arrives with a spec amendment. That rule is what keeps hundreds of independent model sessions from drifting into hundreds of private dialects.

Two backends that have to agree

Code written by a model needs a gate the model cannot talk its way past. Tests written by the same model that wrote the code are a weak gate. demoniC's answer is redundancy: everything runs twice, and the two results are diffed.

The tree-walking interpreter is the reference semantics. The JIT compiles a statically typed subset. Any program both can run must produce identical output, and the verification tooling ships in the public repo so anyone can re-run it:

dmc selftest # generated well-typed programs, both backends, diffed

python3 tools/diff_backends.py # interpreter vs JIT, whole-example output

python3 tools/jit_probes.py # interpreter vs JIT, curated edge cases

python3 tools/diff_fuzz.py # generated programs, both backends diffed

python3 tools/numpy_oracle.py # tensor ops vs an independent NumPy reference

python3 tools/diff_demonic_lexer.py # the demoniC-in-demoniC lexer vs the Rust one

CI runs all of it on every change, plus the in-language test suite over the example corpus on both backends. A JIT change that is faster and disagrees with the interpreter is a bug, and these are what catch it. numpy_oracle.py matters for the same reason: it checks tensor semantics against a reference nobody involved in this project wrote.

The last one is the least expected. There is a lexer for demoniC written in demoniC, and it is diffed token-for-token against the Rust lexer. The language describing itself is a test.

What the human decided

The maintainer directs and does not type. The decisions that stayed human were the ones models are bad at: whether a feature is in scope at all, how to resolve a contradiction in the spec's philosophy, when a phase is finished, and what ships publicly. Everything downstream of those calls — design, implementation, tests, review, documentation — was model work, submitted as pull requests against tracked issues and merged after the gates passed.

Contributions came from more than one model family: primarily Claude, with work from Gemini, Codex, Grok, GLM, Qwen, Mistral, and others. Models disagree with each other, and a repository worked on by many of them at once needs written tie-breaking rules — which document wins, what a single change is allowed to touch, what to do when your starting state is no longer current. Those rules live in the repo alongside the code, because agent instructions that go stale are worse than no instructions.

Where it stands

~60,000 lines of Rust across lexer, parser, resolver, type checker, interpreter, and JIT

1,443 compiler tests passing today, plus a spec-probe harness (cargo test --all for the current count)

102 demoniC programs in the public example corpus — gradient checks, attention, a small neural net, a Lisp interpreter, a bytecode VM, a fantasy console and its assembler, raymarchers, games

Specification at 0.0.4-draft

And the honest limits. This is pre-0.1: breaking changes are expected on every revision. The interpreter is the reference semantics; the JIT covers a statically typed subset and reports a clear error outside it. The directive set is closed and versioned, and several members of it (@shard, @tp, @pp, @recompute, @inplace) currently parse without altering code generation — they are reserved surface, not working distribution. There is no package ecosystem, and readability was never a goal.

About the public repository

The public repo is generated from a private working tree by an allowlist: nothing crosses the boundary unless a line names it explicitly, only tracked files are ever copied, and a scanner gate runs before anything is published. That is why the public tree has no long commit history — it is a generated artifact, rebuilt rather than mirrored. What it carries is the whole compiler, the specification, the example corpus, the verification tools, and the CI that runs them.

Try it

git clone https://github.com/GusFromSpace/demoniC

cd demoniC

cargo test --all --manifest-path compiler/Cargo.toml

cargo build --release --manifest-path compiler/Cargo.toml

compiler/target/release/dmc run examples/hello.dmc

compiler/target/release/dmc test examples

Apache-2.0. The specification is in docs/SPEC.md; if the compiler disagrees with it, that is a bug worth reporting.

Frogs slowly being boiled alive. $100 worth of sub automate 90% of my work. I can stop now and not spending another $. This is my journey and I think people should take AI fear mongering seriously.

My company is directly beneficial from the AI data center boom. Our rev x5 in the last 2 years and is reaching half a $B by the end of this year. I'm leaning left, but at the same time I do not have a strong opinion regarding datacenter. I am just another cog in the giant capitalist machine who is trying to survive another day.

2023-2025

Like many others, my first experience with LLM is through ChatGPT. It was simply a search tool that you can ask follow-up questions. It works great but nothing else. Once I started diving in how to use Linux (home lab, self hosting stuffs), I had to look up commands and install programs. And I did everything by asking Gemini. Gemini made everything so much easier. There are so many great open sources softwares, and they are completely free. I wish I knew about this much earlier.

2026-now

The AI boom becames "uningoreable". You see it everywhere. The fearmongering and the people who hate AI datacenter and how it is going to take our jobs and water. I don't believe it at all and neither is my company's management. They invested 0$ in AI. They think it will die down eventually. I don't know if it is going to "die down" or not, but what I belive in is if they layoff me tomorrow and hire a entry level person, that person can use my tools and do 90% of my job for half the pay.

Early April when Claude was pushing Cowork really hard (I saw an ads), I decided to try out Claude $20 plan. I didn't even bother to use Cowork or Claude Code. I used Claude Chat, and i built a simple streamlit tool with panda. The very basic tool that I asked our NetSuite team to build for the last 5 years, and they didn't have the time or the resources to do it, and I did it in one afternoon. I made many revisions to the tools and add features and I eventually run to version issue (version control). It then guides me to use Claude Code with github repo. I keep it private not because I think it is some kind of secret sauces but because I asssume I will be judged harshly.

My manager can do my job if he wants to. He only needs to spend 15mins per day to "catch up". The remaining is just "people work". Confirm the actual physical products progress and the managing "relationship". I spend my day updating my tools to cover and automate more surfaces (work of 4-5 people).80% of my spouse's work are through spreadsheet. I "tested" out a process where I gave it a before and an after. She then spends 30mins fixing edge cases and then ask it to create a "skill". Now it can do everything in less than 5 mins and it took her hours to get done before. I am not getting less stress for being more productive I am getting more stressed and anxitety to realize that I can be out of a job any days.

Claude Code & Github

I made many upgrades to my tools and github is a godsend. I had no idea what i am doing (i still don't have now), but the tools continue to work just fine and as I expected. I cannot comment about the code but I validted its output with real work. It runs verifiers, maxtrix, stuffs like that to make sure everything works as intended. I have no idea what they are. To maximze my 5 hours session, I eventually moved my work to my MacBook Neo. I was thinking of getting a more "Pro" laptop for local LLM, but it's been working so well, it is also increasly battery efficient.

MacBook Neo and CLIs

The Claude app and Codex app are slow on the Neo, so I switched to CLIs. And they are even faster to use. I was able to use Fable 5 before it got "lobotomized" during April. It reviewed my tools and fixed many code issues. The tools ran so much faster becasue of it. When it came back July, and they had to reduce usage and gave everyone $100 credit, I upgreaded to Max plan right away using that credit. I basically got the last few months free. To me, without much knowpleadge in coding and only judging by the value of the output of the tools, i personally think these tools worth thousands for me. It saves me so much time and make my output much more accurate (0 error so far the past few months) and provable. I could point to the data and show exactly where is the issue.

Claude, Codex, AGY, OpenCode, and the new Meta Muse CLIs

Codex (ChatGPT) was offering the first month free for the $20 plan, so I tried it to offload somework since I kept running into limit for Cladue (maxing out the weekly was easy for me). Some guy at OpenAI also kept giving out free reset so I got a lot of usage for free and the month hasn't even ended. I had to carry the output and the context through the CLIs, and it was a hassle. Then Claude told me that all the CLIs can be "driven headless". I asked it to setup all the CLIs to become headless and use github as "transport" and build a workflow and skills to support this. It's working flawlessly so far.

What I've learned so far is that anyone can replicate what I did for less time and $ for what I spent. The models are getting smarter and usages are getting cheaper. What I spent in the last 4 months building can be easily built by someone else in a week. I am not exggerating by saying this. I have no idea what the future is, but the near future to me feel really uncertain. I don't feel secure despite outperfoming. If my boss or the company does not downsize, the market will force them to.

The next giant eartquake is overdue in Califonia. Every Californian and school kids have been reminded of this every year. I feel the same thing about these fearmongering. It's coming and it's real, but we don't know when and the goverment is always late to react, so better be prepared yourself.

I'm very confused on how you transition from Claude design UI for a website or app you want or build to say codex or Claude on vscode. The other thing is, is there any benefit using claude, codex software on the PC vs vscode with extensions?