DEV Community: Leandro

Home-Bottom Row Modifier Clusters

Leandro — Sat, 30 May 2026 20:29:46 +0000

In the world of custom keyboard layouts, one of the biggest challenges is balancing accessibility with speed. The traditional ANSI layout forces your pinkies and thumbs to reach for distant modifier keys like Ctrl, Alt, and Shift. While "Home Row Modifiers" (HRM) have long been a popular solution, the Kenkyo
layout takes this a step further with Home-Bottom Row Modifier Clusters.

This post explains how we use Kanata to turn the home and bottom rows of a standard keyboard into a high-performance modifier engine.

The Concept: Overloading the Letters

At its core, Kenkyo uses modifier overloads on standard letter keys. Instead of reaching for a physical Shift key, you simply hold a letter on your home row.

In our kanata.kbd, we use a template called charmod. This leverages Kanata's tap-hold-release-timeout logic, but with a special twist we call flowtap:

(deftemplate flowtap (flow tap)
  (switch 
    ((key-timing $streak-count less-than $streak-time)) $flow break
    () $tap break
  )
)

The flowtap logic detects if you are in a "typing streak." If you are typing fast, the keys behave as normal letters to prevent accidental modifier "misfires." If you pause or type a single key, the hold-to-modify behavior is activated.

The Clusters: Home and Bottom Row Synergy

While standard HRM puts modifiers on A S D F and J K L ;, Kenkyo clusters them across the home and bottom rows to reduce finger strain and enable advanced combinations.

Left Hand Cluster (`mhbl`)

Home Row: s (Alt), d (Shift), f (Ctrl)
Bottom Row: x (AltGr/RAlt), v (Fumbol Layer)

Right Hand Cluster (`mhbr`)

Home Row: j (Ctrl), k (Shift), l (Alt)
Bottom Row: m (Fumbol Layer), . (AltGr/RAlt)

By involving the bottom row, we create "clusters" where your fingers can easily rock between a standard modifier (like Shift) and a layer toggle (like Fumbol).

Replacing Physical Keys

On a standard ANSI keyboard, a combination like Ctrl + Shift + T requires awkward contortions. In Kenkyo, this is achieved by holding f (Ctrl) and d (Shift) with your left hand, and tapping t. Your hands never leave the home position.

We even use Chords (pressing two keys simultaneously) to trigger common actions:

w + e = Esc
i + o = Backspace
j + k = Enter

The One-Shot Advantage: Typing at Speed

One of the most powerful features of the Kenkyo clusters is the use of One-Shot Modifiers.

A One-Shot modifier (or "sticky key") stays active only for the next keypress. In Kenkyo, we trigger these using chords within our clusters:

d + k (simultaneous tap) = One-Shot Shift
x + . = One-Shot AltGr
v + m = One-Shot Fumbol Layer

Why One-Shots?

Maintain Rhythm: When typing at speed, holding a key down breaks your "tapping" rhythm. One-shots allow you to treat modifiers as just another tap in the sequence.
Reduced Fatigue: You don't have to maintain tension on a key while reaching for another.
Misfire Prevention: Since the modifier is only active for one key, you don't accidentally "hold" it into the next word.

Advanced Multi-Mod Chords

For power users, clusters allow for complex multi-modifier one-shots that would be nearly impossible on a standard layout. For example, in Kenkyo:

x + d = One-Shot AltGr + Shift
x + d + v = One-Shot AltGr + Shift + Fumbol Layer

This allows you to access deep symbols in the Fumbol layer with a single, coordinated "pinch" or "swipe" of the fingers, keeping your typing fluid and your hands relaxed.

The Home-Bottom Row Modifier Cluster isn't just about saving space—it's about re-imagining the keyboard as a tool where every key is exactly where you need it to be, exactly when you need it.

Porting existing code to Ambler TS

Leandro — Tue, 19 May 2026 19:39:19 +0000

The quickest way to port code from a Git repository into Ambler TS is to include it as a Git submodule and leverage Ambler's agentic skills. We'll use the PocketFlow cookbook as an example.

Project Setup

Create a project folder
Initialize git
Add PocketFlow (or a Git repository of your choosing) as a submodule.
Install the Ambler TS skills

mkdir port
cd port
git init
git submodule add https://github.com/The-Pocket/PocketFlow.git
npx skills add argenkiwi/ambler-ts

Initialize Ambler

Use a coding agent (like Claude or Pi) and invoke the ambler-walk skill:

/ambler-init .

Port Code

Invoke the ambler-walk skill and provide the path to what you want to port:

/ambler-walk create chat walk from @PocketFlow/cookbook/pocketflow-chat

The agent will automatically:

Analyze the source logic.
Create the necessary Nodes in nodes/.
Scaffold a Spec in specs/.
Wire everything into a Walk in walks/.

Test Run

Once the agent finishes, verify the port:

deno test nodes/tests/
deno task <walk-name>

I hope the next generations of gaming consoles are designed to also be your household's LLM hosts so you can use the GPU and unified memory for something useful during work hours.

Leandro — Tue, 19 May 2026 16:37:27 +0000

You can use lteter tiiartnosopsn also kownn as tygmioaypcle, to make the lives of AI agents hrad.

Leandro — Thu, 07 May 2026 23:06:35 +0000

One of the selling points of open source software has always been that you could look at the code and make sure it does what is says it does. But then who could be bothered to read the source code to verify it was legit. Agents can do it for you now.

Leandro — Wed, 06 May 2026 22:29:32 +0000

Ambler TS: a minimal state-machine builder driven by agent skills

Leandro — Mon, 04 May 2026 04:41:31 +0000

Simply install the relevant skills into an empty folder, as explained in the GitHub repo, and describe you program (walk) to your coding agent, detailing its steps (nodes) and how they connect with each other (edges). Ambler TS' skills will help the agent write specs, code and tests for your project in a predictable and modular manner. You can easily run it using Deno.

I have been testing the library using local LLMs within the Pi Coding Agent. It is great for replacing automation scripts and playing with agentic workflow ideas.

Convention over configuration reaches a new level with agent skills. I built a tiny workflow orchestrator (ambler-ts, 52 lines of TypeScript with docs). But it is the skills that enforce the patterns used to write simple, readable and maintainable code.

Leandro — Thu, 30 Apr 2026 22:17:23 +0000

I have been experimenting with agent skills for software design patterns and the results have been very positive so far. I put together an Android (arch26) and Deno (ambler.ts) projects and the results are predictable while tests are written by default.

Leandro — Fri, 17 Apr 2026 16:12:33 +0000

Ambler: rules of engagement with coding agents

Leandro — Thu, 31 Jul 2025 21:58:22 +0000

I recently came across an interesting project called PocketFlow, which presents a minimalistic approach to building workflows that incorporate large language models. It is originally written in Python, a language I have never really used, so I attempted to port it to Kotlin to better understand how it works. As I progressed it became clear the project was simply a glorified state machine and it could be simplified even further. The result was Ambler: a very simple function and a very simple class definition that allow you to express a program as a series of steps that update the current state and pass it on to the next step.

Nothing groundbreaking, but the power of this simplicity is that you can describe your application logically in plain English in a markdown document and then ask a coding agent to build it for you, while keeping the application structure consistent, predictable and easy to understand.

I decided to build a simple counter application as the first example. By not specifying the programming language, Gemini CLI tended to gravitate to using Python. I went along and refined the approach until I got exactly what I wanted. By the end of it I also obtained an equivalent implementation of the Ambler code and the sample in Go, JavaScript, Kotlin, Ruby, Rust and Typescript.

I have observed something interesting when looking into the project on GitHub: the percentage of the codebase written in each language varies considerably for an equivalent implementation. It makes me wonder what the long term impact of using a less verbose, more concise programming language has on your agentic coding costs, assuming there will be a direct correlation between the amount of code needed to solve a problem and the number of tokens used.

I'll continue experimenting with this approach, but I can already see how useful it will become when needing to automate simple tasks. Gemini CLI has already made me a handy application to download URLs from an m3u file which is a great companion to an Chrome Extension Gemini CLI built for me a while ago. All I need now is more ideas to test the approach with.

English will be to LLMs what the QWERTY layout is to keyboards.

Leandro — Fri, 25 Jul 2025 17:56:32 +0000

Should we all learn the Lojban language? It was created to eliminate logical ambiguity , which sounds great for LLMs, and also makes use of a subset of the English alphabet which could be great for keyboard ergonomics.

Leandro — Thu, 24 Jul 2025 01:55:29 +0000

Is Python to AI what Javascript is to the Web?

Leandro — Fri, 11 Jul 2025 00:00:18 +0000

I have been experimenting with Gemini CLI and successfully used it to build a small apps and automation scripts. It seems that, unless otherwise requested, Gemini tends to prefer to use Python as the programming language to use. I can see why:

Relatively simple
Multi-platform
Has a vast ecosystem of libraries
Interpreted

And surely I am missing other advantages that someone with more knowledge about it can point out. It makes sense AI will work better with some languages than others and I even expect new languages to emerge that make it easier for LLMs to work with them. However, I seem to already be building up a collection of useful code written in Python, so I may be inclined to continue to use it so I don't have to install too many different toolchains and I can reuse it when possible.

I would be curious to know if other LLMs prefer other languages, like Javascript or Go, and what experiences other developers have had.