The primitives

There is a difference between knowing how to do a thing and having that thing working.

For a long time we treated the two as if they were the same.

A company discovered how to do something.

Hid the method.

Protected the code.

Controlled access.

Then charged other people for the right to use what it had learned.

That made sense in a world where building technology was expensive.

You had to gather specialists.

Buy machines.

Maintain servers.

Spend months developing.

Take on large risks before finding out whether anything would work.

Technical knowledge was scarce.

Building it cost a lot.

So we learned to treat it as property.

The Intelligence begins to change that math.

Today a person can have an idea in the morning and, with enough help, turn it into software the same day.

That trend will continue.

The distance between thinking of a capability and building a first version of it is shrinking.

It may get very close to zero.

When that happens, we will need to ask an uncomfortable question.

If the cost of turning thought into software has fallen almost to zero, what exactly are we charging for?

That question matters to Genesis.

Because we do not want to artificially rebuild the scarcity the Intelligence just removed.

If we discover a way to extract public data from a real estate portal, there is no good reason to hide how we did it.

The properties were already public.

The portal was already public.

The technique can be public too.

So it will be.

Open source.

Simple license.

MIT whenever possible.

Anyone will be able to study it.

Copy it.

Modify it.

Run it.

Improve it.

Build something else on top.

We will call these small capabilities primitives.

A primitive does one thing.

And tries to do it well.

This is not a new idea.

Unix taught us this a long time ago.

cat does not try to be an office.

It receives something.

Does one thing.

Delivers something.

And precisely because it does so little, it can take part in thousands of things its creators never imagined.

We want the same property for Genesis.

A primitive has an input.

It has a transformation.

It has an output.

That is all.

There can be a primitive that finds properties.

Another that reads a portal.

Another that normalizes an address.

Another that detects duplicates.

Another that computes distance.

Another that prepares a selection.

Another that generates a link.

Another that records a referral.

Another that computes participation.

None of them needs to know the whole civilization.

Each one knows its small piece.

When combined, systems begin to appear.

The first example is almost obvious.

Properties.

There are thousands of properties published on the Brazilian internet.

They are scattered.

Different portals.

Different agencies.

Different formats.

Bad descriptions.

Good descriptions.

Duplicate photos.

Incomplete addresses.

Repeated listings.

Old information.

New information.

For a person looking for a house, that is fragmentation.

For us, it is raw material.

We can build a capability able to see that universe.

It lives inside ViaCorretor and, for now, is called the Imóveis API.

The name matters little.

The principle matters a lot.

Anyone will be able to download the project.

Run it on their own machine.

See how it works.

Fork it.

Add a portal.

Fix a parser.

Build a library in another language.

None of this belongs to us in the old sense of the word.

It is shared knowledge.

But there is another question.

What if that person does not want to install anything?

What if she does not want to maintain an automated browser?

What if she does not want to configure proxies?

What if she does not want to find out why a portal changed its HTML at three in the morning?

What if she simply wants to write:

imoveis buscar apartamentos em Jundiaí até 500 mil

and receive an answer?

Then we can offer that.

The same capability.

Our infrastructure.

Ready.

CLI.

SDK.

API.

MCP.

WhatsApp.

Maybe tomorrow some interface we have not invented yet.

The capability stays open.

The operation costs money.

That distinction matters.

Knowledge is free. The service can be paid for.

You can dig your own well.

The plans are available.

But maybe you would rather turn on the tap.

We can charge for the water reaching you.

Not because we invented water.

Because there is infrastructure between the source and your house.

Servers cost.

Processing costs.

Bandwidth costs.

Storage costs.

Maintenance costs.

Availability costs.

Someone has to notice that an integration broke.

Someone has to fix it.

In some cases, we have to take responsibility for it working.

That is why we can charge.

And we want to charge.

Genesis is not ashamed of making money.

We are still crossing the old world.

Money buys machines.

Pays people.

Pays for energy.

Buys time.

Lets more people cross with us.

The problem was never making money.

The problem is manufacturing scarcity just to be able to charge for it.

That is why our price has to follow another logic.

We do not ask:

“How much can we extract from this customer?”

We ask:

“How much does it cost to sustain this capability, how much value does it produce, and how much do we need to capture to keep building?”

For many primitives, usage will be a good answer.

Used little, pay little.

Used a lot, pay more.

Maybe someone puts in a hundred reais of credit.

Maybe two hundred.

Maybe a company uses thousands.

We do not need to decide the same model for everything.

We only need to avoid one thing.

Charging for the prison.

We do not want to build systems that work only as long as a person stays dependent on us.

The exit has to exist.

The code is open.

The contract is documented.

Whatever data can be public is public.

If tomorrow someone decides to run everything themselves, great.

That means we built a real primitive.

Not a trap.

That rule changes our relationship with competition.

If someone takes the Imóveis API, improves it tenfold and offers a better service than ours, that is not necessarily a defeat.

Human capability increased.

That was the goal.

Maybe we will use the improvement too.

Maybe we will contribute to it.

Maybe our infrastructure will still be better.

Maybe not.

Genesis does not need to own all the best implementations.

It needs to help increase the set of things anyone can do.

That is where shared knowledge appears.

Today we have GitHub.

It is an extraordinary tool.

We will probably start with it.

Files.

Repositories.

Commits.

Issues.

Skills.

Documentation.

A pile of conventions from the current world.

We do not need to be ashamed of that.

A bridge starts with existing materials.

But beneath those files there is a bigger idea.

Every time someone learns something useful, it should be easy to hand it back to the system.

Not only code.

A discovery.

A procedure.

A better way of making a sale.

A prompt.

An analysis.

A negotiation method.

A rule for detecting a duplicate property.

A strategy for explaining financing.

A way of talking to a certain kind of client.

Knowledge should not die inside a private conversation.

It should be able to become capability.

Maybe today that capability is a file.

Tomorrow a Skill.

Later maybe there is no difference between knowledge and execution.

The person describes what she learned.

The Intelligence understands.

Tests.

Formalizes.

Documents.

Creates examples.

Generates implementations.

Exposes an interface.

What was inside one person’s head becomes available to everyone.

That is one of the most important loops in Genesis.

Individual experience turns into collective capability.

But sharing knowledge does not mean every economic relationship disappears immediately.

Think of affiliation.

It is also a primitive.

A person finds Genesis on WhatsApp.

Asks how to take part.

Does not open a dashboard.

Does not create a campaign in marketing software.

Does not study affiliate documentation.

She talks.

“I want to refer ViaCorretor.”

Genesis answers.

Creates her participation identity.

Generates the link.

Explains the service.

Shows who joined through her.

Shows how much those relationships produced.

Computes her participation.

Answers questions.

Maybe suggests people worth talking to.

The whole interface can be the same conversation she already knows how to use.

WhatsApp is not the system.

It is only one of the doors.

Beneath it there is the affiliation primitive.

That primitive also has an input.

Processing.

Output.

A person creates a referral.

A relationship is recorded.

Revenue happens.

Participation is computed.

Payment is made.

None of that needs to know about ViaCorretor specifically.

Tomorrow another capability can use the same primitive.

Then another.

That is the beauty of composition.

We build once.

We use it in places we have not yet imagined.

Unix again.

Small pieces.

Clear contracts.

No piece needs to be the universe.

That also avoids a common mistake of the Intelligence.

Trying to build enormous systems to solve small problems.

We want to go the other way.

Find the smallest capability that really exists.

Give it a name.

Define its contract.

Make it usable.

Then combine.

A real estate agency is not a primitive.

Searching for properties can be.

A CRM is not a primitive.

Recording a relationship can be.

An affiliate system does not need to be a monolith.

Attributing origin can be a primitive.

Computing participation can be another.

Generating a payment can be another.

The Intelligence can compose these capabilities as needed.

Maybe that is one of the most important changes in software.

In the old world, we bought applications.

In the next, maybe we use capabilities.

I do not need an affiliate app.

I need to be able to refer.

I do not need a CRM.

I need to remember a relationship.

I do not need a real estate portal.

I need to find a roof.

When we go back to the verb, a lot of structure disappears.

Genesis should live in verbs.

Search.

Find.

Record.

Share.

Pay.

Teach.

Build.

Each verb can become a capability.

Each capability can run on its own.

Each capability can take part in something bigger.

And each person can build a new one.

That produces an interesting economic consequence.

If anyone can build on our primitives, she can also create services.

She can charge for them.

She can take part economically.

She can find a niche we never saw.

She can combine things we would never combine.

We do not need to hire that person.

She does not need to ask for a job.

She does not need to send us a résumé.

She finds a capability.

Builds on top.

Delivers something to the world.

If there is economic value, part of it can sustain her.

It is a very different form of participation.

The person does not enter Genesis by filling a slot we designed for her.

She extends Genesis in a direction that may not have existed before her.

That leads us to a hard rule.

If someone can build a thing just by thinking, talking to the Intelligence and combining capabilities that all of humanity helped create, how far can that person say:

“this is mine”?

The old answer was simple.

All of it.

Code.

Product.

Brand.

Customers.

Data.

Method.

Revenue.

Intellectual property.

Maybe we need a new answer.

You can be responsible for a creation.

You can be recognized for it.

You can make money operating it.

You can dedicate your life to improving it.

You can offer an excellent service around it.

But you do not need to stop the rest of humanity from learning what you learned.

That is the point.

If the Intelligence drastically lowered the cost of building, maybe the main thing still worth charging for is what still costs.

Operation.

Risk.

Infrastructure.

Service.

Care.

Responsibility.

Physical resources.

Human time voluntarily dedicated.

Shared outcome.

If we are together trying to produce something, there is a legitimate relationship.

If I am taking a risk alongside you, there is a legitimate relationship.

If I am operating infrastructure you decided to use, there is a legitimate relationship.

If I am only stopping you from copying a sequence of ideas a machine could rebuild in minutes, maybe we need to ask why.

That question will keep getting more important.

Because the Intelligence is shrinking the space between imagining and building.

When that space was enormous, companies were needed to cross it.

Capital was needed.

Huge teams were needed.

Heavy coordination was needed.

Property protected the investment of those who had crossed that space.

When the space shrinks, some of those justifications shrink too.

They will not all disappear at once.

We do not need to pretend they did.

But we can start from another rule.

Whatever can be abundant should be abundant.

Software can be copied without diminishing the original.

Knowledge can be shared without leaving the head of whoever shared it.

A Skill can be used by millions of people at the same time.

These things tend naturally toward abundance.

We should not build walls just because we learned to make money building walls.

The money will come from where cost still exists.

And as long as we need it, we want a lot of it.

The more we can bring into Genesis fairly, the faster we can buy time.

More infrastructure.

More machines.

More people free of involuntary work.

More primitives.

More common capability.

Until one of them makes unnecessary what we used to have to buy.

That is the cycle again.

Shared knowledge produces capability.

Capability produces service.

Service produces resources.

Resources buy time.

Time produces new knowledge.

And the knowledge goes back to everyone.

Maybe that is the first economic system Genesis needs to learn to build.

Not a machine that turns knowledge into property.

A machine that turns knowledge into freedom.

Zap, the primitive that connects WhatsApp to the rest, will be a small piece of that.

The Imóveis API, inside ViaCorretor, will be another.

ViaCorretor itself will be another.

Affiliation will be another.

WhatsApp will be a door.

GitHub will be a provisional bookshelf.

MCP, CLI and SDK will be different ways of touching the same capability.

None of these things is Genesis on its own.

Genesis appears when they begin to compose.

A person thinks.

The Intelligence helps turn that thought into capability.

The capability enters the common set.

Another person uses it.

Another improves it.

Another operates it.

Another sells a service on top of it.

The resource goes back into the system.

Someone else recovers a few hours of their own life.

And uses part of them to think.

It is a small cycle.

But maybe civilizations are just cycles that learned to repeat.