How Ubuntu, UCLI-Tools and Pal AI Tool Made My ThreeFold Coding Life Way Faster

#1

How Ubuntu, UCLI-Tools and AI Pal Made My ThreeFold Coding Life Way Faster

Hi friends of the FOSS world :fire:

At ThreeFold and Project Mycelium, we might as well enjoy exploring ideas that can sound almost boring and limited on the surface but which can end up actually pretty groovy and effective in practice. As an example, here’s one: using Ubuntu as a shared base for how we collaborate and build. This means having a single source of coding environment for people across teams.

I’ve always been fond of such thinking, and over the last months I’ve been exploring that vision with creativity and productivity as main vectors.

Out of a very real need to increase productivity and creativity, a whole writing and coding ecosystem emerged in my day-to-day geeking:

  • Ubuntu LTS as the rock-solid base

  • UCLI-Tools as a simple, universal way to install and run tools

  • gits (Git Speed) for working across many repos at once

  • Scott’s pal as an AI “buddy” living inside the terminal

The result? For my day‑to‑day ThreeFold work, research and development, my productivity feels drastically improved in terms of creative output and troubleshooting skills.

This is a story of how that came together, and an invitation to you—especially the ThreeFold builders and app developers—to try this concept yourself.

Why Ubuntu as a base matters

If you want a community to collaborate deeply over many years, you might just need a stable, predictable environment.

That’s what I dig about the idea of anchoring on Ubuntu LTS:

  • You can assume a common baseline of packages and behavior.

  • Scripts and tools you write today will still work in 3–5 years.

  • It’s friendly to servers, laptops, edge devices, and ThreeFold nodes alike.

UCLI-Tools leans into this completely. The whole ecosystem is deliberately designed around:

  • Bash scripts: no heavy frameworks, no magic—just portable shell.

  • Ubuntu LTS: long-lived and boring in the best possible way.

  • Simple install flows: wget + bash + done.

UCLI-Tools: a small, opinionated ecosystem

The UCLI-Tools organization is a collection of focused bash tools under the Apache 2.0 ThreeFold license.

The core ideas (from the UCLI-Tools Manifesto) are:

  • Simplicity – A Uncomplicated Command Line Interface (ucli) as the front door.

  • Modularity – Each tool is just a script; you use what you need.

  • Standardization – Same pattern everywhere: help, install, uninstall.

  • Longevity – Targeting Ubuntu LTS, so tools don’t break every 6 months.

  • Adaptability – Easy to port to newer Ubuntu releases when needed.

  • DIY – Basic template to create your own tools

In practice, this means:

  • There is a main ucli command.

  • ucli knows how to discover, build and install tools from GitHub.

  • Once a tool is built, it becomes a normal command: gits, ucli-docs, etc.

So instead of hand-crafting complex local setups, you can think of it as an app store for bash tools, but fully FOSS and centered on Ubuntu.

Enter gits: Git Speed for multi‑repo work

Now for the fun part.

Most of us don’t work on a single repo anymore. Between ThreeFold, side projects, infrastructure tools, and docs, it quickly turns into dozens of repos spread across GitHub and Gitea (check the ThreeFold hosted git instance git.ourworld.tf and explore some real-world examples of living the FOSS life).

That’s exactly why gits (Git Speed) exists:

A bash script that wraps common git, gh and tea flows into quick, consistent commands—optimized for working across many repos at once.

Some highlights from the gits README that really matter when you’re living in a multi-repo world:

  • Batch repo operations:

    • Clone all repos from a GitHub or Gitea org.

    • Fetch, pull, and check status across many repos in one go.

  • Branch management at scale:

    • Put every repo on the same branch (gits set-all <branch>).

  • Status visibility:

    • Quickly see which repos are dirty, out of date, or clean.

  • Issue and PR management:

    • Fetch issues, manage PRs, and keep everything synchronized.

  • AI-powered commits:

    • Optional integration with pal to generate commit messages.

This is where the productivity explosion started for me.

Where I used to juggle repos manually, now a typical flow looks like:

  1. Pull in an entire org with all its repos (e.g. ucli-tools or threefoldtech).

  2. Save all issues locally so I can give AI the full picture.

  3. Work on issues across many repos in one sitting.

  4. Batch-commit and push all changes with meaningful commit messages.

It’s not just faster—it changes how you think about organizing work.

Of course, it’s a good and vital habit to work in non-production branches and check the code before doing any production levels. All codes should be analyzed and tested.

A day in the life with AI + gits + many repos

Here’s a concrete example from my ThreeFold workflow.

1. Clone everything

First, I pull down all repos from a GitHub organization into a local workspace. Instead of manually cloning 20–30 repos one-by-one, gits does it in one shot, even in parallel.

Now my local tree looks like a small forest of projects: tools, libraries, docs, templates.

2. Bring issues to the AI

Once everything is cloned, I tell gits to fetch and save issues. This turns the scattered to-do items and bug reports into local data I can feed AI.

Instead of asking an AI vaguely “help me with this repo,” I can say:

Here are the issues for this whole org (or subset). Help me plan and implement fixes across them.

Suddenly, AI isn’t just a static code assistant for one repository—it becomes a kind of organization‑level helper that sees patterns across many projects.

3. Hack across repos

From there I bounce between repos:

  • Fixing small bugs in one tool.

  • Improving docs or defaults in another.

  • Tweaking Makefiles or bash helpers across several.

gits keeps track of all that and can later show me which repos are changed and on which branch, so nothing gets lost.

4. AI‑powered mass commit & push

When I’m done with a round of changes, this is where Scott’s pal joins the party.

gits has a push-all command that can:

  • Find every repo with changes.

  • Stage and commit them.

  • Use pal to generate smart commit messages.

  • Push everything in one flow.

There’s even a “yolo” style mode where gits calls pal in an automated way to generate and apply commit messages across all dirty repos. It still respects safety knobs (dry runs, confirmations, etc.), but when you know what you’re doing, this is just unbelievably fast.

The feeling is hard to overstate: you go from “ugh, 15 repos to commit and push” to “one focused flow, and it’s all handled.”

Who is this pal character anyway?

If you haven’t seen it yet, pal (by Scott Yeager) is an AI assistant designed specifically for terminals.

The philosophy is beautiful in its simplicity:

It should feel like a classic shell tool, just one that happens to be wired into an LLM.

You install it as a single binary on your path. Once configured with your LLM provider of choice, you can:

  • Ask for command suggestions: pal <what you want to do>

  • Use /ask for more general questions.

  • Pipe logs, errors, or file contents into it via stdin.

  • And—crucially for us—run /commit to stage changes and generate commit messages.

gits integrates with exactly that /commit flow. So instead of typing message after message, you get commit texts that are:

  • Context-aware (it sees diffs + history).

  • Consistent across repos.

  • Easy to edit if needed.

And because pal lives in the shell, it pairs perfectly with the bashy nature of UCLI-Tools.

Putting it together: Ubuntu + UCLI-Tools + gits + pal

To summarize the stack:

  • Ubuntu LTS gives us a long-lived, predictable foundation.

  • UCLI-Tools gives us a tiny but powerful “ecosystem kernel” for bash tools.

  • gits solves the very real pain of working across many repos and platforms.

  • pal turns AI into a first-class citizen of the terminal, especially around git.

From a ThreeFold perspective, that combination means:

  • You can operate across whole organizations of repositories (e.g. ucli-tools, threefoldtech, internal Gitea orgs).

  • You can align branches, pull new work, and push your changes with a few clear commands.

  • AI is no longer an external website you alt‑tab into—it’s part of the same CLI you use to manage nodes, infrastructure, and code.

That’s how we end up experiencing a real boost in productivity and creativity:

  • x50 personal productivity on top of

  • an already x100 AI coding boost we all felt when we first started using code‑first LLM tools.

Is it an exact number? Of course not. But the felt difference is dramatic.

How you can try this

If you’re reading this on the ThreeFold Forum and want to experiment, here’s a rough starter path.

Assumption: you’re on an Ubuntu machine (desktop, laptop, VM, or server). If not, you can still experiment, but the tools are optimized around that.

If you’re on Windows or macOS, you can get almost the same experience by running Ubuntu inside a lightweight VM or a Docker container and then following the same steps from within that Ubuntu environment. (Deploy a Ubuntu VM on the grid at dashboard.grid.tf)

1. Install ucli

ucli is the universal command that knows how to fetch and build tools from the ucli-tools org.

Once installed, ucli can:

  • List available tools.

  • Build and install them.

  • Keep them updated.

2. Build and install gits

With ucli set up, you can pull in gits from the ucli-tools organization and make it available system-wide.

After that you’ll have a gits command that can:

  • Clone all repos from an org.

  • Run status-all, list-all, fetch-all, pull-all.

  • Manage branches and batch pushes.

  • Integrate with pal for AI-generated commits.

3. Install pal

Grab the pal binary from Scott’s repo, drop it in /usr/local/bin (or anywhere on your $PATH), and configure it:

  • Point it to the LLM provider you like.

  • Run the interactive /config flow.

  • Optionally enable abbreviations and shell completions so using it feels natural.

At that point you can start playing with commands like:

  • pal <describe the command you need>

  • pal /ask <question>

  • pal /commit inside a repo

4. Combine them in your ThreeFold work

Now point gits at a real organization you care about:

  • A collection of ThreeFold‑related repos.

  • A mix of ucli-tools utilities.

  • Internal Gitea repos you use for infrastructure.

Then run through a loop like:

  1. Clone all repos into a workspace.

  2. Save issues and context locally.

  3. Spend an afternoon fixing and improving things, with AI helping you reason about patterns across the codebase.

  4. Use gits push-all with pal to commit and push everything.

After you’ve gone through this once or twice, you’ll probably start customizing your own flows and scripts on top.

Why I think it’s Sweet

It’s not really about this and that code I present, but the overall concept of using modern tools to boost creativity output.

The whole stack is FOSS—largely Apache 2.0–licensed—and it’s meant to be remixed, extended, and adapted.

Quick command cheatsheet

Here’s a minimal sequence you can run on an Ubuntu shell (bare metal, VM, Docker container, or a VM on the grid) to get from zero to a working setup:

1. Install ucli 


# Install ucli

wget https://raw.githubusercontent.com/ucli-tools/ucli/main/ucli.sh

bash ./ucli.sh install

rm ./ucli.sh

2. Install gits via ucli 


ucli build gits

You now have the gits command available system-wide.

3. Install pal

You can both explore the repo and install the recommended single-binary release:


# Clone the Pal repo (optional, for browsing source)

git clone https://github.com/scottyeager/Pal.git

# Install the latest Pal binary (Linux)

wget https://github.com/scottyeager/Pal/releases/latest/download/pal-linux-amd64 -O /usr/local/bin/pal

chmod +x /usr/local/bin/pal

# Run interactive config once

pal /config

4. Try a tiny multi-repo workflow


# 1) Clone all repos from an org (example: ucli-tools)

mkdir -p ~/work/ucli-tools

cd ~/work/ucli-tools

gits clone-all https://github.com/ucli-tools

# 2) Fetch and save issues locally

gits save-issues

# 3) Do your edits with your usual editor + AI workflow

# 4) Review status across repos

gits status-all

# 5) Use AI-powered commits across repos (Pal + (optional) yolo mode)

gits push-all -py

You can just use -p if you don’t want the yolo mode, which accepts the commit message automatically.

Where we really gain speed in a concrete way is using Pal to write commits. It will for example use the nomenclature:


docs: ...

feat: ...

fix: ...

Tracking Code Changes with Pal

After a couple of sessions, it’s nice to go to the whole coding history (git version control management) and see the commit messages: Pal makes it very easy to understand what has been done and where we are in the process.

Of course, it’s wise to start with Pal without yolo mode and get to see the kind of commit messages it writes.

With The Grid

The neat aspect is accessibility. Anyone can explore a Ubuntu experience from any desktop (macOs, or Windows e.g.). Indeed, you can deploy a Ubuntu virtual machine on the ThreeFold Grid using the dashboard: dashboard.grid.tf. Actually there are many ways to deploy on the grid, see manual.grid.tf for more info. Pulumi, Terraform/Open Tofu, TFCMD, TFROBOT…

Feedback

I do dig feedback and would be curious to learn about ways you guys explore coding and geeking in general. :sunglasses:

Thank you for reading!

1 Like