Hacker Newsnew | past | comments | ask | show | jobs | submit | stanmancan's commentslogin

Please explain your work flow!


You set the agents against themselves and burn tokens like there's no tomorrow.

The feeling of coding like that is a bit like realizing that an elevator is 10cm of aluminum and a 100 meters of empty space under your feet.

After the first few bouts of existential dread you get uses to it.


I write a spec by speaking, not much thought given to grammar and sentence structure. I over-describe concepts, over-describe functionality. A lot of repetition of details and concepts. The audience is not a human. Whisper converts it to text.

Lightly manually edit for speech rec failures.

LLM takes that and converts it into a much much denser, much more structured technical spec in markdown. This is issue 1 in the repo.

I edit this directly extensively, adding detail, removing misconceptions, adding sections with more dictated text.

LLM takes this and further densifies it, closer to an actual implementor’s spec. I carefully note what got added, removed, edited in this step.

I edit this carefully and extensively again. Some removals get added back, some additions get removed. This is the first commit and closes issue 1.

I then have an LLM write an implementation plan and basic project scaffolding. Makefiles, smoke tests, logging, test framework, DI. I edit the plan, and the plan is the second commit. An LLM uses both plus scaffolding plus my repo policy documents (global) to write a README. We’re still single threaded.

An agent files the first n top level implementation tickets. These refer to and sometimes quote any interface contracts in the spec or implementation plan. These usually map 1-to-1 to a module/directory. These sometimes have stub commits to create the module directory and commit interface definitions. Some larger modules have a README in their module directory if their purpose or structure or inputs or outputs are complicated or non-obvious.

Parallel agents write commit level issues that are the task items for each top level implementation ticket. One agent per module.

Then, spawn parallel agents with detailed global instructions, the full spec+plan, and the full readme, and the full code from the module it is working in, plus the issue text. Its output is a single commit on the feature branch and a PR that closes out one feature ticket.

This spawns an adversarial reviewer which has detailed agent instructions as well as our code style guides and repo policies. The scaffolding includes tests and linting and checks. Any failures spawn rework agents until the feature branch is up to snuff.

I review the feature branch diff and merge it, having read the review and rework comments on the PR. I frequently add comments about the implementation (“don’t do x, do y”) and add WIP: back to loop it back for more rework. I don’t see anything that isn’t green, formatted, passes linting, passes tests, and a (dumb) bot thinks is ready to land. Most of the time, it is. Sometimes, it did it the wrong way and I correct it.

The more modular the code, the easier it is to parallelize (obviously). It is ridiculously easy to build large software quickly now, provided it is sufficiently modular so the implementation doesn’t have to cross modules very much. The detailed spec and implementation plan up front helps a lot with this. It’s a lot like writing multithreaded programs really.

Any bugs discovered are tackled with strict TDD, one commit with a failing test, one bugfix commit that must be green and not touch the test.

Individual modules must conform to good contracts, meet best OOP practices, and fit into context. Too big and they get broken down further. Context size is actually a useful constraint for code structure here.

This workflow, the code standards, the styleguide, the linter settings, the fmt settings (obviously only applicable to non-Go as the Go fmt is not configurable), everything is global and stored in another repo and is vendored into each AI managed project repo. It has a fair bit of “I shouldn’t have to say this, but…” stuff (in the style of “fire codes are written in blood” - each warning sign came from experience).

My results are quite good. It’s as the saying goes, much like managing a team of junior devs. It is easy to end up with a LOT of parallel implementors, reviewers, reworkers, and tons of CI, but it’s still so much vastly cheaper than humans that it doesn’t matter.

Someone will make a LOT of money wringing out the inefficiencies from this workflow, because I think the “agent as replacement for third-world contracted junior dev” model is the one almost everyone is using right now.


I can’t really decide. Punishments for crimes need to be enough to prevent people from doing them. Guy made millions of dollars fraudulently, what’s an acceptable punishment if it’s not jail time?

Same thing with big companies. They knowingly break the law because the punishment is less than what they gain from it. There’s no incentive not to break the law at that point.


A fine of an equal amount + s&p gains on that amount over that period of time. This is not a person who has indicated they would physically be unsafe in society. Many people don’t have the opportunity to lie at that level, but would, are they dangerous and in hiding?


If they spent a good chunk of it at the time and you don't let them discharge that fine in bankruptcy, isn't that basically a sentence to a life of poverty to pay back the $X million owed? Median US income is about 90k, let's say that left him owing 4M (less than half of 8M + interest), that's 44 years to pay back 4M even if the entirety of your salary was going to it.

Is "forfeit what you've got and go to jail for 18 months" harsher than that? I'd pick the one that let me get a clean start after.

And in the case that it wasn't spent, and by fine you mean as a replacement for any forfeiture, not in addition, then sibling comment has a great point that "if you get caught, you just gotta give it back" is an incentive to commit fraud, not one against committing fraud.


So the worst case for stealing is… returning what you stole…?


I mean, returning what you stole, surrendering the gains you made from what you stole, and covering the gap of the person you stole from seems pretty reasonable? Like, they were made whole. It's a net loss to the thief.

Prison for theft is so brutally cruel. Who was really harmed by this once he paid the money back? A line item in some megacorp that was lower for awhile?

No one felt anxiety or pain, the megacorp probably barely noticed. Pay them back with interest, move on.

Obviously the calculus changes for violent thefts, or breaking into someone's home. Those cause real emotional impacts to people. Of course simply returning those items doesn't make someone whole.


I have had a very different experience so far. The more code AI writes for me the worse it gets. It gets more complicated and it’s harder to follow and understand. It doesn’t refactor, it layers on top.

Even worse is that it’s hard to do anything about it at this point because reviewing code is very different from writing it, so even if I’ve seen it all I don’t have that same deep level of understanding that I do when I write it myself.

All these AI code bases are ticking time bombs. Either AI gets smart enough that it won’t matter in the future or we’re going to have a huge mess to clean up.


> The more code AI writes for me the worse it gets.

That makes no sense unless you're claiming that the models are getting worse at writing code.

> Either AI gets smart enough that it won’t matter in the future or we’re going to have a huge mess to clean up.

My prediction is that both will happen.


> That makes no sense unless you're claiming that the models are getting worse at writing code.

A hypothetical scenario is it needs to add two numbers so it writes add(x,y).

Later on it needs to add three numbers so it writes add(x, y, z)

Then it needs to add four…

Layers upon layers. A human would likely notice the pattern and refactor so add accepts a list.


My experience is that the LLM offers that approach from the get-go.

Also, I've worked with lots of humans who sadly would not notice the pattern.


Can you elaborate for a Hyundai owner?



Surprise, case was voluntarily dismissed. Wonder how much they paid him.


Isn’t that what the agents.md in your project is for?


It's possible I invented skills before they were common. I've always had some instructions in agents.md that are something like "when working with typescript, read prompts/conventions.ts.md, when working with our fooBar module, read prompts/foobar.md"

I'm not sure if this differs greatly from skills. Maybe my wording makes these "skills" less likely to be read at the correct times, but I haven't seen an issue.


I try to keep agents/Claude.md as tiny as possible. With high level "truths" that don't change. Stack used, invariants, file structure, and some scripts.

Skills are more for things you do often. I run mutation tests, type check,linting,etc. I _could_ just prompt and copy/paste the same prompt each time I need to, or I can just run /tests.

I also have skills for specialized tasks I need every once in a while, like a ux skill, a text skill optimized for xyz, etc.


Most guidance I’ve read, and experienced success with, is keeping a lean agents.md file and building out a tree of docs or skills that an agent can navigate via progressive disclosure.


Depends on how much information and details you have. The agents.md always goes into context. Detailed testing or process information might be excessive, when agent is working on UI. Skills are pulled when needed.


I handle the context problem by splitting the details to dozens of small md files. Agents.md acts as a router that directs the llm to correct documentation file/folder according to the task at hand.

This documentation is its own git repo, and the agents.md file has an explicit instruction to update the docs when it has learned something general that can be useful in future sessions. I then occasionally review and prune those docs.


That's exactly what skills do.

The description in the front-matter (at the top of the skill markdown file) is the only thing in the context and used by the agent to determine when to read in the rest of the skill file.


yes, it is. it's almost exactly the same thing.

skills are just an agents.md broken up into chunks so you can manage and share them separately. unfortunately there's no real good workflow for managing or sharing them separately, so most people end up treating them exactly the same way they do agents.md.


Skills are evaluated by short description whether to read them into context.

Skills itself may be lengthy so...


It’s always a hassle trying to find a time for our friend group to hang out, it can seemingly go on for hours. Everyone shares what days they’re available, someone suggests a time, it works for all but one, and the process starts again. That works! Makes the process way easier: when you set your availability it highlights time blocks that works for everyone.

It was a fun use of bitmasks; all availability is stored in 30 minute blocks (0001110000 would represent 1.5 hours available in 5 hours total) and then I use the AND operator across them all to find matching slots.


My problem with hard mode is it leaves a lot up to luck. If it was 3 letters and ended in “at” it could be pat, mat, bat, hat, cat, rat, sat, etc. so all you can do is to pick one and hope for the best.


HN needs an AI flag or something. Not sure how well it would work, but worth an experiment.


Ai generate with human in the loop, so hard to say it’s not while also saying it’s terrible.

Definitely the fact that I have ai makes it more fesable for me to actually publish something rather than spednign years on copy I can spend time on code and outsource copy


The only way to get better at writing is by writing.

I’d rather read a less polished but clearly human written article than something clearly written by AI. If I can’t tell I can’t tell.

Use it for editing or as a review but the weird hyperbolic AI stuff makes me instantly close an article. I barely got past the intro:

  ONE ATTRIBUTE. EXACT BEHAVIOR.
  
  The markup says what happens.
  
  Start with local behavior. Add the server only when the interaction needs to cross the wire. The attribute is moo= — in case you were wondering what the ox says.


„You’re absolutely right” ;)

Your onto something here, thanks - the title and the section where the things I’ve spent more time on than the rest

I mean this „ Behavior, right where it happens. moo= for reactive signals and ordinary JavaScript on the element itself. Datastar SSE when the interaction has to cross the wire and patch HTML and state.”

Still feels bad but I know I went trhu it couple of times. Not so much with the new sample you give here.

Gotta work on that. Thanks!


I only shared because it might very well be cool stuff but if people are tired of AI writing and close it like me then it’s a lost opportunity. Not publishing at all is a bigger loss though, so it’s a tricky balance.


Exactly my thoughts. Decided to publish and iterate.

Deslopifying over time could verywell be a viable approach.


Agree. AI generated is not bad if it's well directed and audited in a loop by a human in good detail. I won't discard a project because a tool has been used. That's extremism. I'll take a look at the project first.


Hope you’ll like it. At least concepts, I know htmx live or datastar are more mature so there’s no discussion about it.

Would you have any hints what to avoid for „next time”? Should I just make this absurdly small and make much less polished approach even for this kind of project? Honest question. Will try to work on anything you suggest <3


> and it's likely producing better output to keep a human in the loop rather than trying to solve the world independently and making multiple incorrect assumptions.

I was just discussing this with a co-worker yesterday. I would really like a model (or harness?) that worked with me instead of for me. Walk me through its choices and decisions, let me correct it and guide it along. I would be way more confident in it's output, I would be more familiar with the changes that are being made, and it would make reviewing the final code way easier since I was making the decisions along side it. I'm sure it would also reduce the "brainrot" we're all going to experience the more we hand work to these models.


Those exist and they're called orchestration skill frameworks like Superpowers, GetShitDone, etc.


does "Superpowers" exist outside of the Claude ecosystem? I feel like I've become hooked on this workflow - honestly I could take or leave the models ... it's the workflows and the way that they essentially create tightly focused loops over multiple sessions that I've becoming fairly dependent on.


Yes, Superpowers is just a set of (agent agnostic) skills that you can use in any harness.


Aside from the skills mentioned, I recently found that asking the model to create a simple HTML presentation to walk you through it's proposed design can do wonders. Fine tune your prompt to your liking (language style, what to include, what not, etc). Then, read that thing thoroughly, and keep asking questions and iterating on the plan until you fully understand what's about to be built, and are happy with it.


the "grill" skill from matt pocock is quite nice for this


To be fair, Apple and Google are on opposite sides of the "respects user privacy" spectrum.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: