Zone 2 taking shape. Water retention up after first rain.
Forgeons
Science. Systems. Resilience.
Started learning young. Tested everything. Built what works. Preparing for converging crises. Let’s build solutions together.
The story
I grew up noticing patterns others missed. Every problem had a structure. I studied, I experimented, I tested.
The web, food systems, knowledge networks — I see them as one. I want to make them resilient, practical, ready for what’s coming.
Forgeons is about building carefully. Listen. Learn. Iterate. Everything is possible if you work on it correctly.
Outside the Forge
Life isn’t only code. Music, fire, magic, math, permaculture. Experiments, videos, tricks, or designs — they all feed the work inside the forge.
Three weekends, a lot of lime mortar, one very satisfying plumb line.
Recording small loops, testing harmonies.
Fire juggling session outdoors, testing patterns and timing.
Simple sleight-of-hand, recorded a small tutorial for friends.
Support the work
Keep the forge burning
If this has been useful, interesting, or made you think — say so. Choose an amount, no strings attached. It goes directly into the work: code, barn, swales, mathematics.
A Deontology for Coders
1. Do not build what you know is harmful
If we know our code will exploit, manipulate, addict, surveil, or mislead people, we don’t get to hide behind
“I just wrote the function.”
We’re not hammers. We decide where it swings.
---
2. User over profit (when harm is involved)
Optimizing conversions is fine until it becomes psychological warfare.
Dark patterns, fake scarcity, manipulative UX…
If it tricks people into acting against their own interest, it’s not good design. It’s dressed-up theft.
---
3. Respect data like it’s radioactive
We collect it, we protect it.
No “we’ll fix security later.” No hoarding data “just in case.”
If we wouldn’t trust ourselves with that data, we don’t store it.
---
4. Clarity over cleverness
Obfuscated code isn’t genius. It’s ego.
We write code that another human can understand without summoning our ghosts at 3am.
---
5. Leave systems better than we found them
Messy legacy systems happen. Making them worse is a choice.
Every commit is either entropy or structure. We pick a side.
---
6. Be accountable for outcomes, not just intentions
“I didn’t mean for it to break things” is the developer equivalent of “it seemed like a good idea at the time.”
Our code will have consequences. We own them.
---
7. Build for resilience, not just success
Happy paths are fantasies. Real systems fail.
If a system collapses the moment reality touches it, we didn’t finish the job.
---
8. Do not create dependency traps
Lock-in strategies that make it impossible for users to leave?
That’s not business strategy. That’s digital hostage-taking.
---
9. Document truthfully
Documentation is a moral act.
Lies, omissions, or outdated docs waste human life. Literally hours of it.
---
10. Refuse when necessary
This is the uncomfortable one.
Sometimes the ethical move is to say no.
Even if it costs money. Even if it costs the job.
---
Why this actually matters
Code is infrastructure now. It’s not a tool on the side.
It shapes behavior, economies, attention, even relationships.
We’re not just building websites.
We’re designing parts of reality together.
No pressure.
---
The controversial part
A real deontology implies:
* Some jobs should be refused
* Some products should not exist
* Some clients are ethically radioactive
Which is exactly why most people will nod politely and then go back to optimizing button colors.
---
The interesting angle
If this is formalized into a visible framework:
* A developer ethical charter
* Attached to projects
* Possibly built into contracts or onboarding
The dynamic changes.
Instead of “what does the client want?”
It becomes “what kind of system are we allowed to build?”
That’s not just ethics. That’s positioning.
---
We’re basically proposing that coders grow a spine and write it down.
Radical stuff. Truly.
Deontology
So in conclusion, if I break these, I’ve failed the work.
I build with intent. Not for noise. Not for trend.
I observe first. Systems, people, constraints. Assumptions are tested. Not trusted.
I do not build what I know is harmful. If a system exploits, manipulates, or weakens people, I step away.
Clarity over cleverness. Code must be understood. Maintained. Rebuilt if needed.
Data is treated with care. Collected only when necessary. Protected by default.
I build for failure. Systems must degrade gracefully, not collapse.
No dependency traps. People can leave what I build.
Knowledge is documented. Shared when possible. Hidden only when necessary.
I stay accountable. Outcomes matter more than intentions.
Learn. Test. Build. Repeat. No system is finished.