If you’re working on an app or software that has few users, no revenue or minimal revenue, tolerance to bugs is higher and just another Claude prompt away, Software factories are a perfect fit. Most personal software or hobby software or 0-1 yet-to-find-PMF startups belong in this category.
You can even take a stand that you’ll never look at the code and just ship. This is a perfect equilibrium for a Software factory, where the only input or feedback is a one-liner/specced requirement and the only output is outcome of whether the one-liner requirement worked or not.
For almost any other software that does not fit this criteria, software factories are yet to solve the Intent and Subjective Quality problem.
Software factories can implement anything given a one-liner requirement. That one-liner requirement can be a complete app/product, epic, feature, bug, design change or refactoring. But these one liner requirements are requirements coming from a human who has an intent or requirement or direction for the product to evolve in mind. Can Software factories manufacture intent that reflects the exact requirements of the person using it or their vision of how the product or software should evolve?
Implementation in any language is as easy as generating a summary for an LLM. If coding is only math and there is only one way to translate a requirement into an implementation, the problem boils down to just providing or verifying generated intent. But, there is definitely more than one way to implement a thing and one of the ways leads to a design and architecture that is coherent with rest of the system, design and architecture that is extensible and evolves, code that you can keep in your head when you want to change things next time or tomorrow, software that can serve millions of users and securely guarantee millions of dollars of revenue. There is a combinatorial explosion of ways and the one right way is also subjective of the person and the problem. Software factories can of course improve Quality by generating more unit tests, more integration tests, fix code violations, generate Proof of work as videos, screenshots etc, but there is no feedback loop or test suite to verify and correct the other subjective notions of Quality.
A job is something where you exchange Skills and Time for Money. Most self-respecting creators/workers will not agree to trade Skills, Time, Privacy, Self-esteem for Money.
Last time I checked, Facebook is not a thing other than for watching AI generated content, Instagram is still a thing to watch mind-numbing content and get distracted from other problems by doomscrolling.
It’s same as language translators and RLHF annotators doing work to contribute to AI training data. Is Facebook or Instagram solving a problem for humanity that’s worth selling your soul? Won’t a job that can be automated with AI training data of clicks and typing, markdown files, next function prediction with no coherence be significantly worse than a job that requires creativity?
How much of this is due to Microsoft Culture of not innovating and buying leading companies with their revenue from windows/office and slowly destroying the aspects of companies that made them great in the first place?
Is all the recent GitHub downtime entirely attributable to GitHub AI Copilot related development? How hard can it be to reduce the blast radius of new AI features to not affect the core parts of hosting repositories? Because of Copilot everywhere, The UX has become bad and I had to click all over the place and on my profile to find repositories.
This is surprisingly good, once you create multiple copies and use each copy as a specialized agent. Maybe we don't need OpenClaw just to manage email, calendar, slack, todo lists etc using natural language.
Agent-kernel has personality, persistent memory, self-modifying capability, using Skills is same as using Skills from Claude code.
Some of the good quotes or analogies in this article:
1 - “It seems like 99% of society has agreed that code is dead.
…It's the same as thinking storytelling is dead at the invention of the printing press. No you dummies, code is just getting started. AI is going to be such a boon for coding.“
2 - Another one comparing writing and coding, and explaining how Code is both a means and an end to manage complexity:
“we're confused because we (incorrectly) think that code is only for the software it produces. It's only partly about that. The code itself is also a centrally important artifact… I think this is a lot clearer if you make an analogy to writing. Isn't it fucking telling that nobody is talking about "vibe writing"?”
You do realize that AI seems magical because text response is converted into actions or tool calls. The AI is deciding the order in which the tools get called to fulfill your prompts. True Intelligence of Type 2 and 3 above needs to formulate, plan, analyse tradeoffs, think critically and solve novel unforeseen problems.
The call flow is:
agent -> select skill (ex: reddit) -> execute action in skill -> script or code associated with skill -> get api key -> call reddit -> reddit posts -> agent.
The agent sees the output of the service, it does not directly see the keys. In OpenClaw, it’s possible to create the skill in a way that the agent does not directly know about or use vault_get command.
This can also be done using existing Vaults or Secrets manager. Hashicorp Vault can do this and agents can be instructed to get secrets, which are set without the agent's knowledge. I use these 2 simple scripts with OpenClaw to achieve this, along with time-scoped expiration. The call to vault_get.sh is inside the agent's skill script so that the secrets are not leaked to LLMs or in any trace logs:
OpenKanban is pretty cool if you’re on the other end and want to use Terminal for both Coding and Task/Project management. It’s almost as good as a Terminal version of VibeKanban, but not so feature rich - https://github.com/TechDufus/openkanban
If you intercept what an agent (client) sends to the LLM with multiple MCP servers and tools, the context or header is filled with available MCP servers and all tools as part of the conversation.
With a CLI, you avoid sending this context to the LLM and it progressively discovers only what is needed.
The input token costs come down because of using a CLI instead of MCP