Genesis

I didn’t originally set out to build an AI framework. I was just trying to get actual work done.

Over time I started using AI inside several very different projects. Some were heavy on content and research, others involved software development, operations, planning, documentation, decision-making, or some combination of all of those. As the projects became more serious, I kept running into the same problem: AI is incredibly useful when you give it enough context, but keeping a real project alive across dozens of conversations gets messy very quickly.

A new chat doesn’t really know what happened before. Important decisions start competing with old ideas. Something that was only a proposal slowly starts sounding like an approved decision. The AI creates folders, roles, trackers and procedures because they sound organized, even when the project doesn’t actually need them. Before you know it, you’ve built a bureaucracy around something that was supposed to save you time.

The bigger problem was that the project itself could start depending on the conversation. If the chat disappears, gets too long, or you need another AI or another person to continue the work, suddenly a surprising amount of the “project” only exists as context inside one conversation.

At first I solved those problems one project at a time. One needed a registry. Another needed handoff documents. Another needed a clear distinction between current decisions and historical material. Another needed rules for when the AI could make a decision and when it had to come back to me.

That worked, until I noticed I was starting to create a different problem: I was copying structures that worked in one project into completely unrelated ones.

A content operation, a software product, a freelance design business and a rental-property operation obviously shouldn’t all have the same organizational system just because one particular system worked well somewhere else.

That was basically where Genesis started.

Instead of trying to build the perfect project template, I started extracting the things that seemed genuinely portable: understand the project before designing its structure, distinguish the project from the person running it, separate authority from responsibility and execution, preserve important decisions outside the conversation, keep current truth distinguishable from history, and formalize things only when the cost of not formalizing them becomes higher.

One of the ideas I care about most is that the project should eventually be able to continue without depending on Genesis itself. I don’t want the framework to become another permanent layer that has to stay alive just to keep everything functioning.

From there, Genesis became something closer to a project compiler.

It doesn’t begin by telling you to create twelve folders, six roles, a database and a weekly review process. It’s supposed to work in the opposite direction: first understand the people involved, the goal, the risks, the resources, how decisions are actually made, what already exists, and where the project is fragile or messy.

Then it asks:

What is the minimum system this particular project needs to remain understandable and operable?

Sometimes that might genuinely be a couple of documents and one conversation. Sometimes the project eventually justifies Git, a backlog, separate operational functions, decision records and a much more serious continuity system.

The point isn’t to keep everything simple forever. It’s to make complexity earn its place.

So what can you actually use it for?

If you’re starting a small software product, Genesis could help you figure out what the product actually is, who makes which decisions, what needs documenting, whether you even need a backlog yet, where code should live, and how different AI development conversations can hand work off without losing the state of the project.

The intended result is not:

Congratulations. Here is your enterprise Scrum organization.

If you’re a freelance designer, the useful system might instead revolve around clients, briefs, deliverables, revisions, approvals, payments and a reliable record of what was actually agreed.

For a content or research project, source quality, claims, versions and research status might matter much more than code repositories or sprint planning.

For something like managing a rental property, suddenly you have vendors, maintenance, guests, expenses, recurring responsibilities and important documents. Some things simply cannot live as “I think we talked about that in ChatGPT three weeks ago.”

And there’s another use case I’m especially interested in: projects that already exist and are already a mess.

Genesis has a reconstruction path for that. Instead of immediately reorganizing everything, it first tries to figure out what exists, what is still valid, what was abandoned, who actually has authority over what, where the current state lives, and what information would disappear if the existing conversations vanished tomorrow.

Only then does it start deciding what deserves to survive.

At this point I’ve packaged the current system as Genesis v0.1-alpha. It’s not an app and there’s no dashboard. It’s a set of framework documents designed to be loaded into a capable AI assistant, which then takes the role of a Genesis Architect and works with you to discover or reconstruct the project and build only the system it can justify.

The current release includes complete English and Spanish editions.

I’ve put the Early Access version on Gumroad for $9.99, and charging for it is actually part of the experiment. I can easily test whether people like the idea for free. What I can’t learn that way is whether somebody who had absolutely nothing to do with creating Genesis looks at the problem and thinks:

“Yeah, solving that is worth ten dollars to me.”

More importantly, I want to know what happens after that. Can somebody download it, give it to an AI and start without me? Does Genesis stay appropriately small, or slowly become bureaucracy? Does it work on projects that look nothing like mine? Can another conversation — or another human — take over later?

And probably most useful of all: where does it completely fall apart?

This is very explicitly v0.1-alpha / Early Access. I’m not claiming I’ve proven that this works universally. I’ve simply reached the point where continuing to test it only on projects I already understand isn’t a particularly useful test anymore.

So now I need strangers.

Genesis:
https://wyzzer.gumroad.com/l/genesis-ai-project-framework

It’s $9.99 and includes both full language editions. If anyone here ends up trying it, I’m particularly interested in what confused you, what felt unnecessary, what worked unexpectedly well, and what broke.

Praise is nice.

A reproducible failure is probably more useful right now.