You'll need nerves of steel to work with AI agents | Hacker News Reader

You'll need nerves of steel to work with AI agents

orchidfiles.com

57 pointstheorchid82 comments

Luna is unusable garbage. When I see people in threads talking about how useful Luna is for all of their tasks and it's so cheap and fast, it reads to me like people relating anecdotes about how tasty the garbage scraps they're eating out of the dumpster behind McD's are. Sol Max is the threshold of "just barely usable", and even then it's certainly not what the people are hyping it up to be.

> But GPT also offers a $100 plan with five times the usage limits. And how long would that last me?

Sol usage is basically unlimited on the $100 plan if you're human-in-the-loop, reviewing the code, and not doing some useless Gas Town crime against humanity.

I’ve been slowly converting my org to use opus 5.5 as default over sonnet and the difference is night and day. More usage, because it does shit better the first time. Less cost, because it does shit better the first time. It’s literally been the thing that’s kicked our org in the pants to actually adopt agentic methodology at scale.

pretty much this, though i did notice a rebound where it can make people meander further into overengineering things, creating a bit of an induced demand

remind opus to not over-enjoy problems

pretty sure they're literally trained to keep offering recommendations that wiĺl keep the session going, so good luck with that

The sentence I shared above helps considerably to use.

In my private coding benchmark Luna Low effort is beaten by Qwen 3.8 Flash Next Coder IQ_1 served by Strata locally https://github.com/niko1221/strata

Luna medium effort is very slightly better than its output and completes tasks in 5-10x less time.

Luna is as great and extremely efficient at exactly what OpenAI advertises it to be good at: focused tasks, small edits, automations.

If it's used for that then using anything more powerful is just inefficient usage of your tokens.

I have found in my own benchmarks that a simple prompt which has a single constraint is reliably ignored by Luna, even on Max, even with another Luna agent reviewing with instructions to check the output against the constraint, at which point they OK it anyways. There is not a single task of any scale I can trust it not to fuck up.

Codex, 6.1 Terra Ultra gets pretty impressive mileage on my plan.

> Luna is unusable garbage

What are some uses for which you found Luna to be unusable garbage?

From my side, I use Harbor to score tasks and Luna certainly performs when the prompt is either well or overspecified.

For me I’d trust Luna to do anything I would a high school student but once we get to college I lose faith.

maybe you just aren't very good at prompting and need the highest level of intelligence possible to kind of make it work?

for myself anything over medium overthinks and is worse.

Oh, fuck off. For one, I work in an LLM startup and work on the harness for our own models, and we're 8-digit profitable, so I'd say I know a thing or two about prompting. For two, there is no prompt that makes Luna work. It ignores your fucking prompt. The OP related how Cursor's model has a quotation mark tic and blatantly ignored a single constraint not to use quotation marks. Luna also has the same deficiency. You can give it a single paragraph prompt with a single sentence constraint not to do X and it will do X every time if it's in the average path for the prompt.

sorry my comment was a bit rude. what i meant was that if you're not vibe coding and instead doing a lot of the architectural work yourself, the less powerful models can still be quite effective for doing the grunt work.

when i built my own harness i had to use sol 6.1 medium, luna, deepseek, etc made too many mistakes, but i was full-on vibecoding it. in other projects when i put more effort into it, models like luna, deepseek, etc do just fine.

Why are you apologizing?

Your comment could be misread as rude by an insecure ("8 digit") person who read that as a challenge to their intelligence and skills, however the reply they gave to your comment is the very defition of rude.

Yes, but then you’re saying Sol Max isn’t good enough. Sol is very capable.

Also, unless I’m overlooking something, you’re spending time within non-codex models, so you’re not going to get the results you’re looking for.

We have dramatically different experiences. I use specification driven design. I have Sol or Opus designed a specification, the plan, and the task breakdown. I then use Luna as the implementation agent. It is told to do test driven development. I have tasks to run tests on just the modified code. Luna knocks it out of the park pretty much every time.

My biggest complaint is that it melds IO concerns such as timeout, with business requirements. Normally, I just to put that in the IO layer. After that, it’s basically done.

Given my pattern, a new feature normally involves Luna creating 20 to 50 files. After it thinks it’s done with its work, a Sol agent will review the code. This loop goes twice. If there’s still issues, I have to deal with them. I’ve not had to deal with them.

This when I’m at work. At home I do pretty much this but with GLM 5.3 Flash. Even less money.

I use Sol 6.1 Max when it's simple to verify the result and for relatively easy stuff and otherwise Opus 5.5.

I have managed to burn 500 GitHub credits on a task with Sol 6.1 Max, but mostly it's below 10 for short stuff. Opus typically being more expensive by a factor of 5-10.

So, full agreement.

Most of these issues are vastly improved or mitigated by adding clear instructions in AGENTS.md.

I follow a specific process with agents, and it works reasonably well: 1) describe my intended feature or change and then say “please recapitulate my intention and write an implementation plan” 2) read the plan carefully and refine it, make any corrections 3) tell the agent to go, but I check in frequently as it’s going. I watch the stream of thought and make course corrections or pull it out of rabbit holes 4) carefully review the result. Checking that tests actually fail, removing unnecessary changes 5) add instructions in AGENTS.md if I’ve found a new behavior that needs redirection

Honest question: how much time are you saving versus ignoring that all of this exists and instead just jumping right in and coding yourself?

At first, maybe not much. But when you're properly set up, it's amazing to watch it cook.

A lot.

I've been doing software engineering for 20 years and approximately half of my total work output has been in the last 2 years. Once you get it set up and maintain it regularly it's easily three to ten times faster

There is no way on earth that you've done more in two years than in 18 years before that. It's not even a remotely believable claim.

I'm just going by github, which has captured the majority of my work since 2007, and says my prior peak was in the ~800 contributions per year, and this year so far I've done 5k+. Not always comparable but close enough I feel comfortable saying "at least 3x"

I used cursor for a project built on a framework with a huge API that I hadn't studied exhaustively. I used a similar workflow with grok for the planning and composer for the implementation. You have to be vigilant, ask questions about the plan, inspect every line of output, and ask for do-overs. At the end I estimated that I would have needed 5-6 months without the coding agent instead of six weeks. I didn't develop as much knowledge of the API as I would have without the coding agent, but I doubt that my employer would have knowingly accepted a longer schedule in exchange for my education. It's not just junior engineers who are going to miss out with coding agents.

Two to three days of up front planning results in a 100x plus productivity gain. Honestly at this point writing code is no longer a blocker for me, it’s more how many agents can I keep running at the same time, how much time can I spend testing and verifying products, etc…

If you have to ask this at this point, I can’t imagine a comment someone could reply that would cause you to update your priors.

Seemed like a reasonable ask. So far, a couple people said 3x to 4x. One said 100x. Big jump. I guess it depends on your baseline coding ability before AI.

No, it's nothing to do with your baseline coding ability, and everything to do with the type of task.

If it's the kind of thing that requires a lot of iterative back-and-forth, like tweaking UX design, then there may be little speedup.

If it's the kind of thing where you there is a clear pass/fail, e.g. writing software to satisfy a comprehensive test suite that is black and white, then it could be 1000x.

The better-defined the task is and the more the agent can evaluate its own success, the bigger the multiplier.

Also, obviously, the more you are working in an area that is more unfamiliar to yourself, the bigger the multiplier.

That's why one morning I'll feel like it's maybe just 2x as it's constantly testing an app in an iOS simulator to see if a UX bug got fixed. That afternoon it might be 10x as it works on some pure code fixes that I still need to verify manually if they work. The next morning it might be something like 200x as I have an incredibly well-defined task that requires a lot of algorithmic research and 10,000 lines of code, but where the end result is easily provably correct or not. That afternoon it could be essentially "inifinity X" as it fixes a problem in a programming language I'm not even familiar with, in a domain it would take me months to get up-to-speed on, in a library I don't know, which solves a bug that is blocking me. Because it's just not something I could have realistically done at all.

So it's incredibly task-dependent. But it's pretty much always faster to some degree. Sometimes a little, sometimes a whole lot, sometimes so much faster it's still a little hard to believe.

Yes very much this. Minor detail of UX sometimes is a time loss with agents.

I caught myself recently explaining something like "resize the top element 30% and move the bottom element up 10%" (except it was slightly more complex).

After a few iterations of that I thought "what are we doing here? I could adjust a single value in the CSS instead of writing complete sentences!". The problem was, then I'd have to go dig up the values and see how it was laid out, which might take more time then writing the sentences. Its still crazy though.

On the other hand, the basic layout was done in 2 minutes instead of half a day so there was that.

In my experience if you are willing to let go and let Claude, then you’ll get sped up in UI stuff.

But if you’re working with a designer and you’re trying to get the agent to get every little thing pixel perfect, they are still complete ass at image understanding at that level. But they can get the broad strokes generally correct.

Seems like more contrived examples than not.

For the generic / average developer pushing SaaS features out on their company's webapp how much faster is it, really?

They are a force multiplier. Unfortunately for my bargain bin offshore strategic partner contractors who were a negative force to begin with, they are now negative 100xers.

Contrived? I don't see it.

For the generic average dev pushing SaaS features, it's way faster. For the kind of stuff where the coding is essentially all boilerplate/connector, something like Claude shines. Because there's already a pattern for everything in the codebase.

If you are able to parallelize your work, e.g. work on 2 or 3 features at a time, your coding time goes down to essentially zero, or rather the time it takes you to write the prompts (hint: use dictation if you're working from home), and all your work is now spent on all the same design and manual testing you were doing before. So depending on what proportion of your time was spent on design/testing vs. writing actual code before, your generic/average dev can see a productivity boost of anywhere from 2x to 20x. It really just depends on what proportion of their job they actually spend literally writing code.

Pre AI a developer would come out of a product meeting knowing at a high level of what to build. Maybe a few key bullet points get written up in an issue tracker somewhere, but beyond that there's no additional design phase, highly detailed specifications curation, prompting, planning back and forth with an agent etc. A good dev has an intimate pre-existing understanding of the codebase, and immediately can just move to the actual implementation (writing code). The plan is in their head, and can go directly to code. And there's no huge agent written code diff to review at the end, and any manual testing happened along the way as code was manually written.

And FWIW, I'm not arguing against a productivity boost. I've tried the tools. But for me, it was nowhere near 10x, especially when working through a brand new feature or module. Maybe 2x, 3x? Though even that seems generous in some cases. And you give up a lot to get that boost with changing the way you work.

Agreed it's higher and probably closer to a 5x-10x for some boilerplate copy/paste duplication or extension of an already existing feature.

Why not give it an honest shot and see for yourself?

It genuinely astonishes me that there are still people such as yourself on HN asking this question.

I understood there were still people asking this 12 months ago. But still?

You could only possibly be doubting the time savings if you simply haven't used agentic development, whether Claude Code or other.

You have to understand, by now you basically sound like someone asking how much time you could be saving by writing in Python, instead of just jumping right in and coding assembly yourself.

If you're still asking the question, you just need to bite the bullet and try it.

> You could only possibly be doubting the time savings if you simply haven't used agentic development, whether Claude Code or other.

I've used Claude Code. It produces no time savings.

Surely you must understand that that sounds as believable as "I've used programming languages. They produce no time savings over assembly language."

If you post something like that, all it says is that you're either trolling or don't know what you're doing.

There are some very specific areas where it might not help, just the same as there are times where writing assembly is still better.

So what exactly is your motivation in saying "It produces no time savings"? Something so obviously false? I just don't get it.

None whatsoever. The boosters are, frankly, lying to themselves and/or to others.

If you've ever been in a meeting that's devolved into coding standards you'll believe me when I say I'd choose writing an agents.md every time

Unlike the OP, this makes using an agent actually sound useful.

My summary of the article: I use a really cheap LLM, and suffer like everyone else using GPT 3.1. This is definitely a throwback to the days not so long ago when LLMs were completely incompetent.

First of all, use Astra with Sol or Opus with Sonnet. Let the bigger model do the high level guiding. Claude Code even has an `--advisor` mode in the CLI. I mix with open weight models as well.

What you want is to branch questions in different agents and this is hard UX.

— Why is this function here?

This question can be but ideally should not be sent to an ongoing chat about a codebase. With some previous context, this question should become a separate "branch"/"fork"/"node" - whatever you call it. You can start a new session, share some context from previous chat and ask the question.

The reason is, and forgive me for assuming, if you are in a code/build flow, the LLM may go ahead and take action because it has a lot of previous chats with instructions to edit files.

In my experience the best way to not have these issues is to branch a new session with some context from which file you were looking at or your previous questions but as a read-only investigation.

> Inability to change the response style In recent months, I’ve been noticing a new pattern in sentence structure more and more often. Here are some examples: There’s a difference between "I read the text" and "I understood the meaning of the text". We too often mistake "I’m used to this" for "I like this". The path from "I’m afraid of making a mistake" to "I’m ready to try" can take years.

It’s worth taking the time to setup a style guide for your agent to remove llm-isms like this. Somewhat paradoxically, you can even have the agent help write it. Just include a couple of snippets of “bad” phrasing from previous chats, add some commentary about why it’s bad, and what to replace it with, and put that in your system prompt. I could provide examples but the whole point is that you can tailor it to exactly how you want it. This has the added bonus of being a quick sanity check for model quality. If you start noticing llm-ism appear, then likely the model is not following your instruction’s and the thread should be discarded/you need to switch to a better model

> No matter how much I try to change the rules and skills for the agents, they keep using this technique.

> Okay, let’s move the rule to the top. In the next reply, right in the same chat, I get text with quotation marks again.

Oh there’s probably some system prompt built in to the harness adding those then. I had to patch the js of the harness I’m using to remove stuff like that from the system prompt to regain full control of the style

Or maybe just luna too dumb idk. I’ve even had good success with a style guide on Bonsai 2 27B though so I doubt luna is dumber than that

> For comparison, let’s take two $20 subscriptions, one for GPT and one for Cursor. With gpt-6.1-sol, my 5-hour limit runs out after just a few requests. If I ask it to change a couple of lines in a readme file, that uses up 10% of the limit. If I ask it to change something in a large codebase, the entire limit gets used up just reading dozens of files, without writing a single line of code.

Either this is hyperbole or something is wrong. I tried 6.1 Sol for a significant chunk of non-critical work this week and did not encounter usage depletion like this. I ran several tests that went upward of 450K tokens without depleting the 5-hour window, though I didn’t pay attention to how much.

Either this person is exaggerating, or something is extremely wrong with their harness.

I’m equally confused that their solution was to switch to Luna and try to use the small and fast model for big coding tasks. They could have switched to Claude $20/month and had ample Opus usage right new.

Most of the complaints in this article could have been avoided by not using Luna and not using a configuration that’s blowing their quota out for unclear reasons.

It depends a lot on how projects a structured. Large monorepos may need a bunch of tool calling, particularly if the boundaries within different parts of the repo are blurred.

I just switched from cursor to codex and had the same impression. One chat with a few messages and most of my usage was gone, and i only used Luna. And it would work for tens of minutes on tasks that would've taken 10x less in cursor. Obviously anecdotal and i feel like the latest update to the ChatGPT app improved it, but maybe some codebases or setups lead to this behavior. Or we are in some kind of A/B test.

Yeah I've never encountered any of that with Opus. It's pretty good at following instructions, and is also careful re anything sensitive or dangerous. Like just a couple days ago a Telegram bot I have it working on made a reply to a message in a chat that it shouldn't have, and I told it to fix the issue and delete the message (I don't have delete permission in the chat). It did the fix and stopped, saying it won't do anything that touches my service account; I had to tell if specifically again to "do the delete" before it did via the bot. Just one of many cases, and the reprompting can sometimes be annoying but I'm also pretty appreciative that there's way less of a chance it'll do something that has me tearing my hair out.

> With gpt-6.1-sol, my 5-hour limit runs out after just a few requests. If I ask it to change a couple of lines in a readme file, that uses up 10% of the limit

raises an eyebrow .. methinks he exaggerates. I don't think my €20 business plan gets more than the plus plan.

A minor README change with basic verification steps is cheap, or you have totally overdone your AGENTS.md / skills / other steering and have it running around in circles.

In general, if the AI needs to dig through a mammoth codebase to make a simple change, it's likely a codebase / design problem.

If you are making a cross-cutting change that needs that, then you plan up front, then divide & conquer.

You're just using a model that's too weak for the tasks you're giving it.

You can go a long way with a weak model but you need to instruct it closely like it's a novice engineer. It's not super productive so it's better to have a smarter agent do the direction. The smarter agent will need context. You may be able to save on the context by building better indexes and docs of the code but you'll need to keep those up to date.

Or you could just use a smarter model, and perhaps a two-phase plan->execute modality. And maybe you need to get your payment card out. $200/month is still not a lot of money compared to salaries.

It's tradeoffs all the way.

This is an excellent summary of the state of the frontier in March, 2026. It was frustrating. However. Things continue to improve, shockingly quickly, at the frontier. These are not major concerns I have with Opus 5.5 or Astra or Sol 6.1.

Don't think you can build anything in a sentence, especially on top of a existing complex codebase. Typically I need to spend 30 minutes to get it spec right for a new feature, and then 30 minutes at the end to get it to review right (not reviewed by me but let it check things that might be missed). And I frequently bang my head against the keyboard: are you opus - these are intern mistakes

You’re using the wrong model for the problem. “Fast and cheap” agents like Luna are good for tightly scoped changes but won’t understand the “why”. Astra or Sol wouldn’t have that issue.

some people are not ready to read and accept this but I will say it anyway: stop reading code and trust that it does what you asked to do, focus on high level architecture and human description of what the system is doing. The only exception to this is if what you are doing carries a significant amount of risk that can't be mitigated with a follow up PR, for example launching a rocket or controlling an airplane.

And that's why we need criminal penalties for supposed software developers

No. That isn't engineering, that is slop.

the slop is driving revenue up

Idk how you are running out of budget so fast. My usage is basically unrestricted tokenmaxxing ("/goal", flagship models at xhigh reasoning, etc) and my monthly burn is single digit thousands of dollars (maybe ~$350/day). Granted, my employer foots the bill so I don't care at all. But the return-per-spend is easily worthwhile and I'm not worried about the cost at these ratios.

Nerves of steel? Not even close.

I think 90% of the article is the author complaining about (predictably) bad small-model behavior. The large models are much better!

It just gets worse as your codebase grows with more code and more files especially. It's like a human developer who is under intense time pressure. If the codebase is large, it might miss an existing function and implement a second one... or it might miss the fact that a database table already exists to solve its current problem and create another one. The solution is to keep the codebase as simple and small as possible and name everything as intuitively as possible with proper separation of concerns. Same principles which were useful before AI are still useful with AI.

I don’t understand how it will ever overcome something like not replicating an existing function. It can’t possibly have full context on a massive codebase at all times so additional prompt runs checking for existing functionality would be necessary.

Even scarier is something like a legacy change made for a specific client, like “our biggest client needs checkboxes as the UI, do not switch it to a dropdown.” was in a commit message 2 years ago, AI will just overwrite that without thinking.

There are solutions for this that those of us with the rare combination of experience, time and management buy-in are using - but they’re scary to people all-in on AI tools.

I’m talking about deterministic checkpoints and hooks. In every environment in which I need to use a coding agent I have had to essentially build a harness outside of the harness to be measurably productive. If you’re not using deterministic tools to box in what the agents are capable of doing, the problems you describe are ten times more rampant than anyone wants to admit.

If your files are named well and codebase is of reasonable size, it will find them and re-use them. I haven't experienced the problem of duplicate functions at all on any of my personal projects. The trick is that my code is separated into distinct modules in a clear hierarchy with one-way dependency; no module has more than 5k lines total, no more than 20 files or so. Basically, I treat every part of my system as an independent, fully self-contained black-box product which could potentially be used by third-parties in different business domains. The interface of each module is generally quite simple and it doesn't expose any internal details.

My AI agent never has to work with more than 5k lines of code and like 20 files at a time; and most are much smaller than that; like 1k or 2k lines... Even though one of my projects is almost 30k lines, my AI agent never has to consider more than 5k.

It's a very different experience in my day job because the project has more lines, more files and all the files for the entire project are in the same repo and naming is not as clear. In this case, I have to point to the relevant files/context in every session.

Larger models realize that a function might already exist and look around for it.

> was in a commit message 2 years ago, AI will just overwrite that without thinking.

Should be fixable by telling the model to check if there's a reason why something exists by checking the git history of that piece.

Only talking about Sol Max and Opus.

How people are getting anything done at all with less than 5-6 claude max and 4-5 codex pro max plans and codex-lb and better ccflare juggling weekly limits at all times, I will never know.

What is that, like $35 worth of DeepSeek usage per month?

lmao, probably

Some of the things you described about the bot reversing decisions after you question it and how it randomly deletes files based on your responses - it sounds rather unrealistic.

I haven’t experienced anything like that. My first inclination is to shout: skill issue. Because steering these language models is our responsibility. Reading 10 files doesn’t lead to 10% usage gone even on my $20 subscription. Try talking to your internet friends and find a better way to steer these agents.

Yea honestly I used to use claude sonnet all the time on pro plan and it had problems like this, but moved up to a max plan and opus makes it almost impossible to go back, higher usage limits aren't worth it if they force you to wrestle with ur agent all day instead of getting a ton built and running out of usage in an hour.

Sorry you had to suffer.

Bad models & bad harnesses are like blunt knives.

You are ironically more likely to hurt yourself if your knife is blunt - and less likely to get the job done. Once you do get the job done, it'll take longer and suck.

So,

Step 1: delete Cursor.

Life gets better from there.

"Why is this function here? *Discuss.*"

Ocasionally it discusses with itself and decides to just keep going and do the thing anyway. But yeah, I use “discuss” a lot and it works pretty well.

You are right and here is my hot take into why working with models is a f pain. Harness... yes I have one https://github.com/alainnothere/privibe but is not what mine has that the other doesn't but what it doesn't have.

I suspect the whole reason for how bad models accessed through subscriptions tied to a harness of the provider (looking at you copilot) is that microsoft in the case of copilot "builds into the harness and hence into the model" an intention; and I don't have proofs (which qualifies me to start a popular podcast) but I suspect the harness keeps pushing the model to fix an issue as quickly as possible so the service can appear as "it just bam fixed the issue".

The "sitius altius and fortius" of the technobro is what you see in the tv ad "copilot check my git and fix a bug", how stupid do you think someone has to be to believe it works like that? my instructions to model say that I HATE urgency to make changes, we are researching and until we figure out causes, and understand all the mechanism involved AND THEN AND ONLY THEN we can check what's the actual intention, what business wants... then we can talk about a fix.

Grab a harness that injects the minimum possible and let the agent be and you will see how much difference there is in the quality of the model response.

Sounds exactly like the fever dream I see everybody live, lol

At this point I’d pay money for a good course on how to use AI for coding.

I’m not a Luddite, and the thing I most need at work now is a mid-seniority dev to support me. I don’t care if their name is Tanner, Prateek, Claude or Luna, I’ll take the help, except the meat-based variant is, IME, near impossible to hire (beats me - so many devs in the market, but the CV stack is deeply underwhelming, and the interviews only worse).

But every time I try to use AI agents - and frankly I only use the frontier ones as work pays for tokens - it’s basically what the author describes. Lots of random changes. The model happily saying it is doing X while also doing !X and also Y and Z, and sometimes gets stuck in some weird loop. Last time (admittedly not a frontier model but not far off) it wrote a Python script which would write another text file, with the contents defined as a concatenation of chr(XX) characters. That was enough.

Fixing or reviewing all this nonsense, or babysitting the model line by line takes more time than doing the damn thing myself.

What makes it worse is the cadence of babysitting an LLM is really awkward. Again, I don’t know what Im doing wrong. But reviewing things every 10 mins destroys my attention span. Even a junior dev is better in this regard - give them something to work on, describe what you need, review 1-3x / day for a week, and you hope to get somewhere. Even if it takes a long time, it’s not a major effort, so long as you’re ok with the latency. LLMs are the opposite - low latency, high noise. Lots of little efforts frequently, and all requiring full attention - because it’s easy to miss the little “rm -rf /” or other Easter egg Claude left.

So in short, it matches the behavior TFA describes. And yet lots of people see to be able to derive a lot of value out of it.

I have a lot of success writing medium length snippets with it, in a conversational style. Sort of up to 500-1000 LOC in things that aren’t challenging. Or building a scaffolding for a webpage. Or a non judgmental, zero lag replacement to SE/SO. But a mid senior dev ain’t that.

It’s not just a rant, any suggestions welcome.

Try this: Use Opus 5.5 on high. When it says it's done, ask it to review the change with a sub agent and with Codex Sol 6.1 high and to fix and iterate on the reviews until both reviewers are happy or the findings are nitpicking. Each re-review should be in a fresh context. In my experience, the result of this is very good.

Since what you describe what you want matches my recent switch to working as an "engineering director" of my agents, shameless plug for my own setup (non commercial, open source): https://obeya.si.

ask your agents to teach you how approachable, well build setup work. either open source, either what the other plugged-in in the comments.

ask why at every answer your agent gives you. when it's clear, set it up. make it work for you, not you fitting the game

i started copy pasting 2 years ago, and it's ok

enjoy!

TL;DR: you get what you pay for.

Reply on news.ycombinator.com