I have used Vim and Emacs long enough that editing is mostly muscle memory. That is a good thing, but it can also make an editor feel like infrastructure: always present, rarely questioned. Exploring Helix has reminded me that editing can still be enjoyable.
Helix is a modal terminal editor with a selection-first approach. It is not Vim with a different theme, and it is not an attempt to recreate everything Emacs can do. I have had to adjust some habits. In return, common actions feel direct: select what I want to change, then act on that selection. Multiple selections, tree-sitter-powered syntax awareness, and language-server integration make the editor feel capable without requiring a large personal configuration project.
The pleasure of a smaller surface
For years I have valued the extensibility of Emacs and the precision of Vim. I am not abandoning either. But I do not always want to maintain an editor ecosystem before I can edit a file.
My preferred loop now is often simple: use Yazi to locate a file, open it with hx, make a focused change, return to the shell, run the relevant check, and continue. Helix is the editing surface; the shell remains the execution environment.
That distinction is why Helix fits my terminal-first philosophy. I do not need one tool to contain my entire workflow. I need the pieces to connect predictably.
Rust, Python, and Elixir in the same workspace
Rust is a particularly comfortable fit: rust-analyzer can provide navigation, diagnostics, and completion when installed and configured. Python benefits from language servers such as basedpyright or pyright, with formatting and linting handled by tools I choose. Elixir can use ElixirLS for language intelligence, while mix remains the natural place to run tests and other project tasks.
Helix includes language configurations, but language servers, formatters, and runtimes are separate dependencies. I check what is actually available rather than assuming a feature works because a file has syntax highlighting:
hx --health rust
hx --health python
hx --health elixir
A normal session might look like this:
hx src/main.rs
cargo test
hx scripts/check.py
python3 -m pytest
hx lib/my_app/application.ex
mix test
Those are separate shell commands, not editor magic. The ability to move between them quickly is the point.
Helix as part of an API client workflow
I often need to test an authentication flow or an API integration. Rather than switching to a heavy GUI client, I can edit a text request in Helix and execute it with Hurl, a command-line tool for HTTP requests and assertions.
For example, a small .hurl file can describe a harmless local health check:
GET http://localhost:8080/health
HTTP 200
[Asserts]
jsonpath "$.status" == "ok"
Then I edit and run it from the shell:
hx tests/health.hurl
hurl --test tests/health.hurl
This is an API-client workflow built around Helix, not an HTTP client embedded inside Helix. The editor does not need to become the HTTP client. Hurl performs the request and checks the response. For one-off exploration, curl or HTTPie may be sufficient; for repeatable tests, a checked-in Hurl file becomes a useful, reviewable artifact. Real authentication requests should use appropriate test environments and secret-handling practices—never hard-code production bearer tokens in files destined for Git.
This is a good example of why I prefer text. The request, expected result, and test history can all live with the code. A colleague can review the change without reconstructing a sequence of GUI clicks.
AI generation belongs in the same loop
I also use AI-assisted code generation, including Codex, as an accelerator. I treat its output as a proposed change, not an authority. The useful pattern is not to ask a model to take over the editor. It is to give it a bounded task, inspect the proposed patch, and verify the result with the same tools I already trust.
For example, I might ask Codex to propose a Rust handler or generate a Python test, then inspect the diff in my terminal and use Helix for the final edits. An Elixir refactor still needs mix test; a Rust change still needs cargo test; a Python change still needs its test and lint checks. Generated code does not become trustworthy simply because it compiles.
git diff --check
git diff
# Run the project-specific tests before committing
I keep credentials, customer data, and sensitive architecture details out of unapproved AI prompts. The boundary between generating code and executing code matters, especially when commands can touch files, networks, or privileged systems.
Fall back to the shell, by design
There are features I miss from Emacs. There are things Vim does differently. Helix has limitations and its own learning curve. None of that is a reason to build an elaborate workaround for every missing capability.
If Helix does not do something elegantly, I can use the shell. rg searches, fd finds, hurl tests, jq transforms JSON, git shows what changed, and Yazi takes me to the next file. If I need a native macOS application, open is there too.
That is what makes this experiment fun rather than frustrating. I am not choosing an editor to replace my computer. I am choosing an editor that makes the editing part feel good again.
The wider story began with windowing and the return to tmux, then Yazi as my terminal Finder. Helix completes the loop: navigate, edit, execute, inspect—and keep moving.