pramodbiligiri

I too felt the need for some structure around AI coding, and created a spec-based tool earlier this year: https://www.shipsmooth.net/. I'm happy using it. I think of it as "light-weight" and encouraging iterative development over specs+code. It creates just one spec file and one "tasks" file for each unit of work. Available as a plugin for Claude, Codex etc.

It's still flaky: https://www.isitdownrightnow.com/tornadovps.com.html. They have a blog post regarding the outage (may not load if it's also been affected): https://tornadovps.com/blog/2026/07/distributed-denial-of-se....

As the linked page describes, “Tornado VPS is a focused, old-school VPS provider that has been active since 2005, originally under the Prgmr.com name. They do one thing only – Linux and BSD virtual private servers on Xen – and they clearly target people who already know how to manage a server.”

Their main site (https://tornadovps.com) has been down for hours, and probably all sites hosted on it: https://www.isitdownrightnow.com/tornadovps.com.html

How would this be different from Apple's recently launched "container" utility? https://github.com/apple/container

I feel that flow state[1] is possible as long as you don't feel distracted into doing other things and you're needed to guide the LLM along every few seconds/minutes (someone mentioned a pair-programming type tool in this thread). For me that works if you have a good spec + workflow tool (assuming you're doing interactive coding and not kicking off long running coding jobs). I feel that a good test of a workflow tool is that it should offload all bookkeeping from you, leaving you to just read the generated code and think about design/architecture.

I built one such tool for myself: https://www.shipsmooth.net. You can use it to spec/plan out a piece of work, and then easily keep updating the spec/plan as you churn through its implementation. The tool assumes that you will pretty much end up changing the spec/plan during implementation, based on how it's going. In general, I don't see how it's possible to one-shot high quality code for custom use cases.

[1] Going by the definition of flow state here: https://en.wikipedia.org/wiki/Flow_(psychology): "fully immersed in a feeling of energized focus, full involvement, and enjoyment in the process of the activity. In essence, flow is characterized by the complete absorption in what one does, and a resulting transformation in one's sense of time."

It's possible they are running at a loss at present. But in a recent podcast their founder said he believes inference is profitable, based on their experience serving models: https://newsletter.pragmaticengineer.com/p/opencode (search for "profitable")

It would be interesting to see if LLM's can scan and surface such issues. Might have been probable with parsing tools pre-LLM also? Not sure.

I believe “sessionization” is a common term used for this: https://dev3lop.com/blog/sessionization-in-clickstream-event...

Fairly predictable given the times: a plugin for coding assistants that supports a development workflow that I like :) It's at https://www.shipsmooth.net/.

Perhaps the more interesting bit is that it's in Java (not Typescript or Rust)! Java 25 is pretty neat. Bonus: getting to know how to distribute a self-contained Java program using jlink and the likes: https://docs.oracle.com/en/java/javase/17/docs/specs/man/jli...

Yeah it was very disappointing that so few details were provided. One of the reasons I think it's going to be an open source project or effort that is going to show, sooner or later, how effective these things actually are.

In their podcast interview, they mention that it's an Electron app that users download, and so they periodically create a new build. See section "Autonomous Merging Flow" here: https://www.latent.space/p/harness-eng

There was one good analysis from that viewpoint recently: https://x.com/addyosmani/status/2059844244907696186

I'm not convinced of this bit: "it revealed three things as the real bottlenecks (1) deciding and specifying what to build, (2) verifying and being accountable for what is delivered, and (3) the deep human understanding — of the codebase, the business, and the environment — required to carry out both of these."

It could be that because coding was seen as expensive and a bottleneck, much effort (both upstream and downstream) had been going into making sure its input is correct and the output need not be discarded. If coding is seen as a quick and cheap step, its output could stand to be thrown away and therefore the same amount of oversight may not be needed upstream?

They seem to address that: "This is sharply different from occupations such as agriculture in which labor demand was famously decimated due to mechanization and automation. The difference is that the amount of calories people consume is relatively fixed — even a 25% increase led to the obesity epidemic — whereas the amount of software produced has grown a millionfold."

Google released "Modern Web Guidance" a few weeks back that includes a set of agentic skills: https://github.com/GoogleChrome/modern-web-guidance-src. I wonder if that includes some of the suggestions in this article.

Have you been interviewed by any of the top talk shows? Would love to see this discussed on Bill Maher, for example.

I hadn’t heard of libgit2. I wish more applications would expose library-style access, preferably available across different languages!

May not work for apps that want to launch their own threads and processes. But for almost everything else, I prefer function calls to launching processes, managing their lifecycle, communicating via stdout etc. If I wanted to do that, I’d be writing Bash ;)

How does one know that a website is "vibe coded"? Any good indicators?

Because I thought this is a good blog and more people should get to know. Found it by chance in some other thread: https://news.ycombinator.com/item?id=48414452.

Did the same with this Cloudflare one the other day: https://news.ycombinator.com/item?id=48276152

Have you been satisfied with the quality of code generated by the model? Or did you have to tweak some rule file or skill to improve it? Or is human-readable code not even a goal at this point?

This is a great interview! I had to switch from the transcript to watching it though - the transcript had many mistakes.

(OP here) The truth is much simpler. I mailed the mods and they bumped it up in the second chance pool [1] :)

1. https://news.ycombinator.com/item?id=26998309

As other commenters have clarified, it's about layering, separation of concerns etc. Goes by many names. One such terminology here: https://en.wikipedia.org/wiki/Hexagonal_architecture_(softwa.... DI frameworks use terminology like "Provider": https://en.wikipedia.org/wiki/Dependency_injection#Injectors

I agree with many of the points made by nimonian above (esp the one starting with 'make a single skill called "code" which describes the lifecycle'), based on my limited experience with these things.

I'm building a skill + CLI tool along those lines (for solo devs not corporates). Here is what my "lifecycle" type skill looks like right now: https://github.com/bitkentech/shipsmooth/blob/releases/dist/... (warning, heavily work in progress). You can see a demo here: https://shipsmooth.net/

I was not happy with the default code quality generated by Claude Code. So I've been adding some skill-file rules to address that, and so far happy with the results: https://github.com/bitkentech/shipsmooth/tree/main/skills/ex.... There was a similar one on HN yesterday called opencodereview: https://news.ycombinator.com/item?id=48406358

There are many such workflows out there! Matt Pocock gave a good talk about how he approaches it: https://www.youtube.com/watch?v=-QFHIoCo-Ko

My approach (with LLMs especially) aligns more with what's outlined in "Growing OO Software Guided by Tests" (https://growing-object-oriented-software.com/toc.html). Chapter 4 there says "First, Test a Walking Skeleton", and Chapter 5 has "Start Each Feature with an Acceptance Test". I think it comes down to: get something working end-to-end first in a verifiable way, and then keep refining both the feature and its tests (preferable with TDD).

I've noticed that LLMs tend to generate multiple testcases in one shot (which is not how humans usually go about TDD), and also they don't start with Integration Tests, unless instructed to do so.

I don't think the idea of skills is quite snake oil. It seems you can change what LLM outputs next by what's called few-shot prompting or in-context learning: https://www.promptingguide.ai/techniques/fewshot

Anthropic's developer documentation: https://platform.claude.com/llms.txt. There's also https://platform.claude.com/llms-full.txt which is (WARNING) much bigger. Not sure where this second one fits into the standard.

A repo with the English translation of each of the rules files, using Google Translate: https://github.com/pramodbiligiri/open-code-review-rules.

The original rules files (in Chinese): https://github.com/alibaba/open-code-review/tree/main/intern...

Thermonuclear suggested by someone below is good. Matt Poccock did a demo/breakdown of that: https://www.youtube.com/watch?v=mh5XZ-L5SFQ. He has his own "improve-codebase-architecture" skill: https://github.com/mattpocock/skills/blob/main/skills/engine...

Some of them are about general coding guidelines and code quality, not necessarily vetting your current PR against specs! There's AbsolutelySkilled with clean-code and clean-architecture. Linking to older version of repo because they seem to be no longer on trunk: https://github.com/AbsolutelySkilled/AbsolutelySkilled/tree/...

I've been creating some rules to help with my Java coding: https://github.com/bitkentech/shipsmooth/tree/main/skills/ex.... These are assembled into a SKILL file when this skill file template is built: https://github.com/bitkentech/shipsmooth/blob/main/skills/ex...

Mechanics of running their command aside, I think the main value add is all the rules: https://github.com/alibaba/open-code-review/tree/main/intern...

Like with "SKILL" files in general, it's got to do with Prompt Engineering: https://en.wikipedia.org/wiki/Prompt_engineering#Rationale