language: en kae3g ← back to index
(unlisted) — This essay is not shown on the main index but remains accessible via direct link

Your Tundra

One approach to creating your own flowing environment of precision and clarity

Introduction: Welcome, Traveler

Imagine you're a Martian who has just stumbled upon this strange repository. You see code, essays, automated workflows—all growing together in patterns you don't quite recognize. What is this place? How does it work? Could you grow one yourself?

Welcome to the tundra.

This repository—this Coldriver Tundra—is an experiment in living soil computing. Like Helen Atthowe's ecological farms, we're not just placing files on dead storage. We're cultivating a soil food web where:

The soil gets richer over time, not depleted.

This essay documents one approach to cultivating such a system. Your garden will differ—this is just how ours grows.

A Note on Simple vs Easy (Before We Begin)

Rich Hickey teaches us: Simple and easy are different.

Simple (from simplex—"one fold"): Not intertwined. One role. One task. Objective, measurable.

Easy (from adjacens—"near at hand"): Familiar. Close to current understanding. Subjective, depends on experience.

This tundra:

The trap: Easy tools (JavaScript, WordPress, drag-and-drop builders) often hide complexity that appears later—dependencies break, platforms change, vendor lock-in.

The path: Simple tools (Babashka, Git, static files) might feel unfamiliar at first, but complexity stays manageable as your garden grows.

We choose simple, knowing it requires patience. The Martian who learns these patterns can rebuild this garden on any planet, from first principles, a decade from now.

Part 1: Foundation - Tools & Accounts

Your Machine (macOS Sequoia)

Required:

Install Homebrew (if not present):

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Core Development Tools

Install via Homebrew:

brew install babashka node git

What these do:

Verify installation:

bb --version    # Should show v1.x.x
node --version  # Should show v20+
git --version   # Should show v2.x

Part 2: AI Services - Multi-Model Strategy

Why Multiple AI Services?

Each AI has unique strengths. In my experience, using them together can help create richer, more nuanced work, though your mileage may vary:

ServiceStrengthUse For
Claude (Anthropic)Power & depthComplex reasoning, long context
ChatGPT (OpenAI)Mission clarityStructure, coherence, flow
Grok (X/Twitter)Real-time searchCurrent events, X integration
DeepSeekPoetic writingBeautiful prose, creative expression
Gemini (Google)YouTube/SearchResearch, multimedia context
Qwen (Alibaba)Code strategyFuture-proof open models
MetaEssence distillationSummarization, core concepts

Service Setup

Cursor Pro (required):

Grok (optional, requires X Premium):

DeepSeek (optional):

Gemini (optional):

Qwen (optional):

Meta Llama (optional):

Part 3: Codeberg - Sovereign Git Hosting

Why Codeberg?

Codeberg is not GitHub:

Create Account:

  1. Visit: https://codeberg.org/user/sign_up
  2. Choose username (lowercase, no spaces)
  3. Verify email
  4. Generate SSH key (next section)

SSH Key Setup

Why SSH keys?

How Cursor Can Help with SSH Keys:

If you're new to SSH keys or encounter issues, Cursor can guide you through the entire process:

  1. Ask Cursor: "Help me generate an SSH ed25519 key for Codeberg on macOS and add it to my account"
  2. Cursor will provide: Step-by-step commands, troubleshooting for permissions, and verification tests
  3. Common issues Cursor helps with:
    • SSH agent not running: Cursor will help start it with eval "$(ssh-agent -s)"
    • Permission denied: Cursor will fix file permissions (chmod 600 ~/.ssh/id_ed25519)
    • Key not being used: Cursor will add the key to ssh-agent with ssh-add ~/.ssh/id_ed25519

Generate new SSH key:

ssh-keygen -t ed25519 -C "your-email@example.com"

When prompted:

Copy public key to clipboard:

cat ~/.ssh/id_ed25519.pub | pbcopy

Add to Codeberg:

  1. Go to: https://codeberg.org/user/settings/keys
  2. Click "Add Key"
  3. Paste your public key
  4. Give it a name (e.g., "MacBook Pro")
  5. Click "Add Key"

Test SSH connection:

ssh -T git@codeberg.org
# Should see: "Hi <username>! You've successfully authenticated..."

If you see "Permission denied", ask Cursor: "SSH connection to Codeberg failing with permission denied, help me debug"

Git Configuration

Set your global Git identity (required):

git config --global user.name "Your Name"
git config --global user.email "your-email@example.com"

Tip: Use the same email as your Codeberg account for consistency.

Verify configuration:

git config --global --list

GPG Key Setup for Verified Commits

Why GPG signing?

How Cursor Can Help:

Cursor (with Claude or GPT-4) excels at helping with GPG setup because it involves multiple steps, potential errors, and platform-specific commands. Here's how to use it:

  1. Ask Cursor to guide you through GPG setup:
    • Open Cursor
    • Press Cmd+L (or click the AI chat icon)
    • Type: "Help me generate a GPG ed25519 key for Git commit signing on macOS and configure it with my Codeberg account"
  2. Cursor will provide step-by-step commands with explanations for each step
  3. Follow along and ask follow-up questions if anything fails

The process Cursor will guide you through:

Step 1: Install GPG (if not present):

brew install gnupg

Step 2: Generate GPG key (ed25519 - modern, secure):

gpg --full-generate-key

When prompted:

Step 3: Get your GPG key ID:

gpg --list-secret-keys --keyid-format=long

Output will look like:

sec   ed25519/ABC123DEF456 2025-10-11 [SC]
      1234567890ABCDEF1234567890ABCDEF12345678
uid           [ultimate] Your Name <your-email@example.com>
ssb   cv25519/XYZ789GHI012 2025-10-11 [E]

The key ID is ABC123DEF456 (the part after ed25519/).

Step 4: Export public key:

gpg --armor --export ABC123DEF456 | pbcopy

(Replace ABC123DEF456 with your actual key ID)

Step 5: Add GPG key to Codeberg:

  1. Go to: https://codeberg.org/user/settings/keys
  2. Click "Add Key" → GPG/SSH Key
  3. Select "GPG Key"
  4. Paste your public key
  5. Give it a name (e.g., "MacBook Pro GPG")
  6. Click "Add Key"

Step 6: Configure Git to use GPG:

# Tell Git to use your GPG key for signing
git config --global user.signingkey ABC123DEF456

# Enable GPG signing for all commits
git config --global commit.gpgsign true

# Ensure GPG uses the terminal for passphrase (macOS)
echo "export GPG_TTY=\$(tty)" >> ~/.zshrc
source ~/.zshrc

Step 7: Test GPG signing:

# Create a test commit
mkdir test-signing && cd test-signing
git init
echo "test" > test.txt
git add test.txt
git commit -m "test: verify GPG signing"

# Verify the signature
git log --show-signature

You should see gpg: Good signature from "Your Name <your-email@example.com>".

Cursor's Assistance Throughout:

Common issues Cursor helps solve:

  1. "gpg: signing failed: Inappropriate ioctl for device"
    • Cursor will add the GPG_TTY export to your shell config
  2. Email mismatch between Git and GPG key
    • Cursor will check that git config user.email matches the GPG key's email exactly
  3. Key not found by Git
    • Cursor will verify git config user.signingkey is set correctly
  4. Pinentry-mac not working
    • Cursor will suggest switching to pinentry-tty or configuring gpg-agent

Pro Tip: Ask Cursor to create a checklist document for you:

"Create a checklist document for SSH and GPG setup on macOS with Codeberg that I can reference later"

Cursor will generate a markdown file you can save to your repository (e.g., docs/SETUP-KEYS.md) for future reference or to share with team members.

Part 4: Repository Structure

Create Your Repository

On Codeberg:

  1. Click "+" → "New Repository"
  2. Name: your-tundra (or whatever you like)
  3. Description: "Experimental aspiringly helpful generative AI writings"
  4. Public (for Pages to work)
  5. Initialize with README: No (we'll create our own)
  6. License: Dual (Apache-2.0 / MIT recommended)
  7. Click "Create Repository"

Local Setup

Clone template (use this repo as starting point):

# Clone Coldriver Tundra
git clone https://codeberg.org/kae3g/12025-10.git your-tundra
cd your-tundra

# Change remote to your repo
git remote remove origin
git remote add origin git@codeberg.org:YOUR-USERNAME/your-tundra.git

# Create your branch
git checkout -b main

Directory Structure

your-tundra/
├── writings/              # Your essays (markdown)
│   ├── 9999-start-here.md
│   ├── 9998-next-essay.md
│   └── ...
├── web-app/              # SvelteKit site
│   ├── src/
│   ├── static/
│   └── package.json
├── scripts/              # Build automation
│   ├── writings_build_incremental.clj
│   └── deploy-to-pages.bb
├── docs/                 # Documentation
│   ├── DEVELOPER-GUIDE.md
│   ├── BUILD-SYSTEM.md
│   └── QUICK-REFERENCE.md
├── bb.edn                # Task definitions
├── .gitignore
└── README.md

Part 5: Configuration System

Your Tundra uses a two-tier configuration system: public/personal settings vs. private/secret data.

Understanding the Two Tiers

Tier 1: Public/Personal Configuration (.config.edn)

Tier 2: Private/Secret Configuration (.secrets.edn)

Create Your Public Configuration

Copy the template:

cp .config.template.edn .config.edn

Edit .config.edn with your personal settings:

{:site
 {:username "your-username"    ; Your display name (shows in top-right)
  :language "en"               ; Primary language: en, es, de, fr, ja, zh, ar, pt, ru
  :title "Your Tundra"
  :description "Your description"}

 :author
 {:name "Your Name"
  :email "you@users.noreply.codeberg.org"
  :url "https://codeberg.org/your-username"}

 :repository
 {:platform "codeberg"
  :username "your-username"
  :repo-name "your-tundra"
  :branch "main"}

 :localization
 {:timezone "America/Los_Angeles"
  :locale "en-US"
  :date-format "YYYY-MM-DD"
  :planned-languages ["es" "de"]}  ; Languages you plan to support

 :preferences
 {:editor "cursor"
  :theme "dark"
  :monospace-font "Courier New"}}

Important: This file is safe to commit! It contains no secrets. The site will automatically read your username and language from this config.

Create Your Private Secrets (Optional)

Only needed if using AI APIs directly (most people won't need this initially):

cp .secrets.template.edn .secrets.edn

Edit .secrets.edn with your PRIVATE API keys:

{:git
 {:signing-key "YOUR_GPG_KEY_ID"}  ; From Part 3

 :git-hosting
 {:codeberg
  {:token nil
   :ssh-key-path "~/.ssh/id_ed25519"}}

 :ai-services
 {:openai {:api-key "sk-..."}     ; Only if using OpenAI API directly
  :anthropic {:api-key "sk-..."}  ; Only if using Claude API directly
  :deepseek {:api-key "..."}
  :google {:api-key "..."}
  :grok {:bearer-token "..."}}}

Important: This file is in .gitignore and will NEVER be committed. It's for local automation only.

How the System Works

When you build your site:

  1. bb config:generate reads .config.edn (public/personal)
  2. Generates web-app/static/site-config.json (for the web app)
  3. The site loads this config and displays:
    • Your username (top-right, golden ratio position)
    • Your language (top-left)
    • Your site title
    • Your repository info

When you run local scripts:

Benefits:

Internationalization Vision

Current: This tundra speaks English (language: en)

Near future (next planned languages):

Long-term vision (all languages welcome):

Why internationalization matters:

How to add a language (when ready):

  1. Update .config.edn: Set :language to your code (e.g., "es")
  2. Create writings/ essays in your language
  3. Add translations for UI elements (optional, later work)
  4. Build and deploy: bb flow "feat: Spanish translation"
  5. Share with your language community

The long-term goal: A constellation of tundras, each in its native language, all building on the same frozen foundations. Spanish speakers learning Nock. German speakers exploring s6. Arabic speakers building sovereign systems. Chinese speakers proving formal correctness. French speakers documenting ecological computing. Japanese speakers optimizing for minimal complexity.

We start with English because this tundra's author writes in English. But the system is designed for all languages. The templates support it. The config system enables it. The vision demands it.

If you speak another language fluently, your translation work is a gift to the commons. Fork this repo, translate the essays, change :language in your .config.edn, and share. The frozen clarity of the tundra speaks all tongues.

Part 6: Your First Essay

Create Essay 9999

cat > writings/9999-beginning.md << 'EOF'
---
title: "The Beginning"
date: 2025-10-11
---

# The Beginning

This is my tundra. A flowing environment of precision and clarity.

Here I will explore [your topic], guided by [your philosophy], 
building toward [your vision].

**My multi-AI strategy**:
- Claude for deep reasoning
- ChatGPT for structure
- [Add your chosen AIs]

**My principles**:
- [Your principle 1]
- [Your principle 2]
- [Your principle 3]

The journey begins.
EOF

Build & Preview

# Install dependencies
cd web-app && npm ci && cd ..

# Build content
bb writings:build-fast

# Start dev server
cd web-app && npm run dev

Visit: http://localhost:5173/your-tundra/

Part 7: Deploy to Codeberg Pages

Enable Pages

On Codeberg:

  1. Go to repo → Settings → Pages
  2. Source: Branch
  3. Branch: pages
  4. Path: / (root)
  5. Click "Update"

First Deployment

# Make sure everything is built
bb deploy:full

# Or use bb flow to commit + deploy
bb flow "feat: initial deployment - my tundra begins"

Wait 1-2 minutes, then visit: https://YOUR-USERNAME.codeberg.page/your-tundra/

Part 8: Cursor Pro Workflow (Your REPL)

What's a REPL?

REPL = Read, Eval, Print, Loop

In Lisp/Clojure, you write code and instantly see results:

user=> (+ 1 2)
3
user=> (map inc [1 2 3])
(2 3 4)

Tight feedback loop: Type → Test → Learn → Type again.

Cursor + bb flow = REPL for essays:

Write → bb flow → See live site → Write again

You're not writing blind. You're conversing with your tundra.

Cursor Setup (Your Pollinator)

Install Cursor:

  1. Download: https://cursor.sh/
  2. Install, open, sign in with Pro account
  3. Open your tundra: cursor /path/to/your-tundra

Configure:

Configure AI settings (critical for best results):

  1. Settings → AI → Models
    • Enable all available models (Claude, GPT-4, o1, etc.)
    • This gives Auto Mode full range to choose the best tool
  2. Settings → AI → Mode
    • Select Auto Mode ⭐ HIGHLY RECOMMENDED
    • Lets Cursor intelligently pick the best model for each task
    • Amazing results: Auto Mode has been giving us exceptional output—it picks Claude for complex reasoning, GPT-4 for structure, o1 for deep problem-solving
    • You get the best of all models without thinking about it
  3. Settings → AI → Model (fallback when not using Auto)
    • Set to Claude Sonnet 4.5
  4. Enable auto-completions

Note: All models in Auto Mode are included in your Cursor Pro subscription ($20/month)—no extra charges within reasonable limits. The polyculture approach (Auto Mode) consistently outperforms using just one model.

The REPL Dance (Cursor + bb flow)

Example session (like a Clojure REPL, but for prose):

# Open file
cursor writings/9998-essay.md

# You: Cmd+L
"Help me write an essay about [topic], inspired by Helen Atthowe's soil ecology"

# Claude: (generates draft)

# You: Edit, refine, @-mention related essays
# Claude: Cross-pollinates ideas from your existing writings

# You: Test the cycle
bb flow "draft: essay 9998 initial thoughts"

# Build succeeds → pushed → deployed
# Visit live site, see your essay
# Notice what needs work

# You: Back to Cursor, refine
"Make this section more concrete, add examples"

# Claude: (improves)

# You: Test again
bb flow "improve: essay 9998 added examples"

# Repeat → Each cycle enriches the soil

You're not "writing and publishing"—you're gardening in real-time.

Multi-AI Polyculture

Like Helen's polyculture farms (many species, not monoculture), use many AIs:

Cursor (Claude) → Primary development, code, structure ChatGPT (browser) → Mission clarity, flow, coherence Grok (X) → Real-time research, current events DeepSeek → Poetic polish, beautiful prose Gemini → YouTube transcripts, search integration Qwen → Open-source patterns, future-proofing

Diversity is resilience. If one AI changes, your workflow adapts.

Part 9: The bb flow Command (Your Water Cycle)

The Living System

In Helen Atthowe's farms, water cycles are everything:

Your tundra has a water cycle too:

bb flow "your commit message"

5 phases (like water moving through an ecosystem):

  1. 🌧️ Precipitation → Build content (markdown → JSON)
    • Tests your changes in isolation
    • Like rain testing soil absorption
  2. 💧 Infiltration → Stage changes (git add -A)
    • Changes soak into version control
    • Like water entering the soil
  3. 🌱 Root Uptake → Commit (only if build succeeded)
    • Changes become part of the living history
    • Like plants taking water from soil
  4. 🌊 Transpiration → Push to Codeberg
    • Changes flow to the community
    • Like water vapor rising from leaves
  5. ☁️ Condensation → Deploy to Pages
    • Changes become visible to all
    • Like clouds forming and raining again

The Fourth Phase (Gerald Pollack)

Gerald Pollack's research: Water has a fourth phase beyond solid/liquid/gas.

EZ Water (Exclusion Zone):

In your tundra's water cycle:

The build phase (Step 1) is like water organizing into its fourth phase:

bb flow "message"
  ↓
Build starts (markdown → JSON)
  ↓
Your changes are TESTED, VERIFIED, STRUCTURED
  ↓
Like water molecules organizing into crystalline layers
  ↓
Only STRUCTURED changes flow forward
  ↓
Bad changes are excluded (like the Exclusion Zone rejects impurities)

Why this matters:

The cycle repeats. Each iteration enriches your repository's history with crystalline precision.

Why This Pattern Works

Simple (Rich Hickey):

Ecological (Helen Atthowe):

REPL-like (Cursor + AI):

Part 10: Multi-AI Synthesis

The Power of Multiple Models

Each AI has blindspots. Using multiple models together creates something greater than any single AI could produce.

Example Essay Creation Flow:

Phase 1: Research & Ideation

Grok (X Premium):
→ "What's trending about [topic]?"
→ Real-time context

Gemini (YouTube/Search):
→ "Find expert videos on [topic]"
→ "What do scholars say?"
→ Deep research

Phase 2: Structure & Outline

ChatGPT:
→ "Create an outline for an essay on [topic]"
→ Clear mission, logical flow

Claude (Cursor):
→ "Expand this outline with arguments"
→ Deep reasoning, nuance

Phase 3: Writing & Refinement

Claude (Cursor):
→ Write first draft (power + depth)

DeepSeek:
→ "Make this more poetic and human"
→ Beautiful prose

ChatGPT:
→ "Does this flow well? Fix transitions"
→ Structural coherence

Phase 4: Code & Deployment

Qwen:
→ "Future-proof this code pattern"
→ Sustainable architecture

Claude (Cursor):
→ Debug, refactor, optimize
→ Final implementation

Phase 5: Synthesis & Distillation

Meta Llama:
→ "Summarize the essence in 3 sentences"
→ Core message extraction

Claude:
→ "Integrate everything coherently"
→ Final synthesis

Recording Your AI Process

In each essay, document which AIs helped:

---
title: "Essay Title"
date: 2025-10-11
pipeline: multi-ai-synthesis
ai_contributors: ["Claude", "ChatGPT", "DeepSeek", "Grok"]
---

**AI Synthesis Note**: This essay was developed through 
collaboration with Claude (reasoning), ChatGPT (structure), 
DeepSeek (prose), and Grok (research).

Why document this?

Part 11: Customization

Your Own Metaphor

Don't copy "Coldriver Tundra" - find your own environment:

Examples:

Choose based on:

Your Own Colors

Edit web-app/src/lib/theme.css:

:root {
  /* Your light theme */
  --color-bg: #your-color;
  --color-fg: #your-color;
  /* ... */
}

:root[data-theme="dark"] {
  /* Your dark theme */
  --color-bg: #your-color;
  /* ... */
}

Test with:

cd web-app && npm run dev
# Click * toggle to switch themes

Your Own Structure

Essay numbering - you choose:

Just be consistent and update the sort in:

Part 12: Maintenance

Daily Workflow

# 1. Write
vim writings/9998-essay.md

# 2. Preview
bb writings:build-fast
cd web-app && npm run dev

# 3. Deploy
bb flow "feat: add essay 9998"

Weekly Tasks

# Update dependencies
cd web-app
npm update
npm audit fix

# Clear old cache if issues
rm ../.build-cache.edn
cd .. && bb writings:build-fast

Monitoring

Check CI status: https://ci.codeberg.org/repos/YOUR-REPO-ID

Check site: https://YOUR-USERNAME.codeberg.page/your-tundra/

Check git status:

git status
git log --oneline -10

Part 13: Advanced Patterns

Multi-Language Support

Add translations:

writings/
├── en/
│   └── 9999-essay.md
├── es/
│   └── 9999-ensayo.md
└── fr/
    └── 9999-essai.md

Update build scripts to process subdirectories.

Series & Collections

Use front matter:

---
title: "Essay Title"
series: "Tundra Philosophy"
part: 3
total: 10
---

Filter by series in index generation.

Rich Media

Embed images:

![Alt text](../assets/image.png)

Embed videos:

<video controls>
  <source src="../assets/video.mp4" type="video/mp4">
</video>

Custom Components

Create Svelte components:

<!-- web-app/src/lib/Callout.svelte -->
<div class="callout">
  <slot />
</div>

Use in markdown (with MDsveX plugin).

Part 14: Community & Sovereignty

Why This Matters

You own your tundra:

You control the AI:

You preserve knowledge:

Forking & Remixing

This repo is dual-licensed (Apache-2.0 / MIT):

Give credit (but not required):

Built on [Coldriver Tundra](https://codeberg.org/kae3g/12025-10)

Sharing Your Tundra

Codeberg Pages is public - anyone can read.

Share your URL:

Connect with others:

Part 15: Troubleshooting

Build Fails

# Clear cache
rm .build-cache.edn
bb writings:build-fast

# Check specific file
bb -e "(require '[markdown.core :as md]) \
       (println (md/md-to-html-string (slurp \"writings/9999.md\")))"

Deploy Fails

# Check .gitkeep exists
ls web-app/static/content/.gitkeep

# Ensure remote is correct
git remote -v

# Test SSH
ssh -T git@codeberg.org

Site Not Loading

Part 16: Next Steps

Your Journey

Week 1: Setup & first essay

Week 2: Find your rhythm

Month 1: Develop your system

Year 1: Your body of work

Resources

This Repository:

External:

Conclusion: Your Flowing Environment

Dear Martian traveler,

You've seen how this tundra grows:

Living soil (Helen Atthowe):

Simple tools (Rich Hickey):

Water cycles (bb flow):

Polyculture AIs (Multi-model):

Every tundra is unique. If you build one on Mars (or Earth), yours might reflect:

Some foundations are shared - frozen specifications, simple tools, water cycles, living soil. But the environment will be yours.

If this approach resonates, you might start with:

# A first command
mkdir my-tundra
cd my-tundra
git init
# The soil is ready. Begin planting...

Built on permafrost. Written with AI. Grown by you. Owned by the commons. ❄️🌱🌊

For the Martian: When you return home, take these patterns with you. They work on any planet with Git, any civilization with simple tools, any species that values living systems over dead infrastructure.

The tundra awaits your footprints.

Appendix: Tool Versions (as of 2025-10-11)

License: This essay and the Coldriver Tundra codebase are dual-licensed under Apache-2.0 / MIT. Use freely, modify as needed, build your own tundra.

Ready to Begin?

You've seen one approach to building a tundra—a system for writing, thinking, and creating with AI assistance. You've seen the tools, workflows, and multi-AI strategy that have been helpful for this project.

Whether you build your own or explore what others have built, there's more to discover. Return to the main index to see essays on computing systems, philosophical foundations, and community-driven technology. Or experiment with your own tundra—the flowing environment is there if you want it.

← Back to Main Index

← back to index