DEV Community: Miguel Valdes

You shouldn't use Neovim

Miguel Valdes — Mon, 23 Feb 2026 16:00:00 +0000

I know this will sound weird specially coming from someone that lives and spends 70% of my time living in a terminal and using neovim btw but sometimes it's really ok to not use the hot and cool tool that people tell you to use.

Granted it's a great editor and ecosystem and it will make you blazingly fast by just getting the hang of vim motions but the more I keep reading on discords channels and subreddits, people are jumping into the ecosystem by copying what they see in the internet and when Neovim or the plugins get an update and hell breaks loose which happens pretty often they are completely clueless on what to do or have zero interest in learning how to fix it which goes against the entire reason why people like us tinkerers go into using it in the first place!

Sometimes it is ok to just have vim motions in other editors like VSCode or Zed, you don't really have to use the hot tool if you are not going to spend time into learning what it is and how it works.

If you really want to join in and fully commit to this cult, cause yeah sometimes it has a cult like behavior... probably the reason why you are trying it in the first place... then please come on in, we have cookies and a bunch of lua for you to enjoy and also there are great creators out there preaching the gospel and showing you how it works and why you should use it.

Some of my favorite resources are:

Rant::init()

Don't be like this when asking for help in your neovim setup.

1. Try to do some research
2. At least share the full error
3. Touch some grass pic.twitter.com/9e1BQkWquK
— Miguel Valdes (@mr_mvaldes) December 27, 2024

The community on it's own is pretty good at helping people out but my brother in Neovim you also have to use your head a little and when the message is something redundant like....

Option X has been deprecated, please remove it from your config

New version requires a depepdency on plugin 'author/plugin-name' please include it in your configuration

You gotta read a bit and try some stuff on your own.

[!tip]
If you haven't cared enough to try on your own why should I?

This is in general an AWESOME skill to have as an engineer, be resourceful, don't be afraid to try and fail. If you truly did best effort it's still broken then by all means ask away, but seriously don't just ask or inquire if you haven't done the minimal effort of even trying. It's something I always teach new people I train on my teams throughout my career, basic troubleshooting skills which may come out as an asshole move but trust me down the road they all thank me.

Rant::done()

So please come join us but be ready to try and succeed!

Adios 👋

n8n is pure awesomeness

Miguel Valdes — Thu, 19 Feb 2026 18:30:00 +0000

One of the big benefits of having a Homelab and plenty of services running locally is that I can start connecting them together and using them for various things. TLDR, automating like crazy. Not to mention that there are some things running on the wild internet that I do not plan to self-host and those are still valuable to me and want to integrate them into my whole ecosystem.

Do want to point out you can also use some of these services by paying a subscription as most things nowadays, you could use free tiers but once you hit a limit, hide your kids, hide your wallet.

Now, whenever I do automation at home, 90% of the times it is a very repetitive pattern:

Start putting together a bunch of bash scripts that would call something to retrieve some data
Format or parse the data. Enrich as needed.
Send a payload elsewhere and eventually achieve the automation’s objective.
Profit

That approach worked for a couple of years, especially for notifications whenever something went down in the Homelab that needed my attention and things like Grafana couldn't handle already, so with more services running locally and more integrations running I discovered the no-code automation tools that made things so simple that even someone that isn't a “tech bro” would be able to use them.
On top of that, the hype with AI made automation even more desirable since it could also be expanded to develop these so-called “AI Agents,” which to me are basically (Hot Take of the week 🔥) big cronjobs that either run on a schedule or react to an event, following an event-driven architecture design, but doesn’t take off the fact they pretty much just do the same methodology of the automation pattern mentioned above.

So, enough history, what am I using and what am I doing with it? – I’m running a local version of n8n which again you can get started using their free tier but since I have the hardware I always try to run things myself to keep my data under control we self host it.

Now, what am I using it for? – Don’t have an answer per se for that since it can pretty much connect to thousands of services so I’m going to give you some example workflows.
️

Get the weather

This one is kind of dumb but as a busy father I need to be prepared for the weather so the kids use the proper wardrobe for the daily activities so I have designed a simple workflow that runs every day at 7AM giving me the current weather in a notification via Telegram.

Daily review of my Todoist tasks

Todoist is my default task manager so as someone that tries to follow GTD, I tend to dump everything out of my brain into the tool quickly and every now and then I review the list of tasks in the system, but since things then to go all over the place within my project I needed to go into each one of them to try and find what was overdue, without labels or dates. Well no more as I have a workflow that kicks off and does that for me, everything that don't match a filter or criteria will get a label @review so I can easily spot them and organize my tasks.

Sync Tasks-Issues in Github

Some of the tasks in my manager are related to small little projects I have on Github like my twitch-bot or my k8s homelab applications, so whenever I want to do something or try a new tool I create a "ticket" for myself, which having in todoist is probably enough but since those project are open for the public I once had some issues created in one of the repos for a neovim plugin I made and I completely ignored it for weeks since i rarely review that section within Github so in order to make it all easy to find and use the workflow syncs things between systems now.

This one took a lot of time as I ended up having repetitive things in either tool so a database had to be included to keep track of what was already in a either system.

Adopt a Dog

This is the one I'm most proud of, I basically created a web scrapper that goes against my local shelter and grabs the results when new pups are added to the site, which I then put on a table with the details like Breed, Size, Date of Birth and any descriptions or comments which is then sent over to me via notification using Gotify, another service I want to use more for everything notification related.

That's only the beginning

AI is here to stay so the next workflow I do will use some model to do something fancy, I have yet to find a good use case for it but I will be ready with the infrastructure to run it as I also run my own models locally thanks to Ollama.

Conclusion

What I love about the whole n8n ecosystem is that it can be triggered by a lot of different inputs or events, most of the ones I came up with are still cron timers BUT I've been playing with Webhooks and getting them to work and trigger something took me less than 3 minutes which is great as it abstracts the complexity of standing up the Web server and listener for you as it can dedicate a specific endpoint for each workflow which can call other workflows, I've seen videos on the youtube about people having automations with 40+ nodes that do some convoluted actions as well as people claiming that these so called "AI Agents" are being used to make money which I don't doubt a single bit they make some actual real money as the tool can integrate with thousands of other systems so for people running a business this totally makes sense.

Would recommend that you try it out and get some automations going on, you don't need to be a proficient coder to get these working so the barrier of entry is incredibly low and thats a good thing!.

The days of doing bash scripts are over for me....?

Until the next one,
Adios 👋

How I Use Obsidian for Everything (Almost)

Miguel Valdes — Mon, 16 Feb 2026 19:34:00 +0000

One App to Rule them all

It's been almost a 2 years since I moved everything into a single little application you may have heard about, called Obsidian. The initial migration was just to move all of my wiki entries on tech stuff I'm currently learning or using like my Kubernetes/Docker/Linux notes as well as entries related to concepts like Event Driven Design, TDD or programming languages I'm learning like Go/TS/Lua/Rust.

After migrating 50 or so notes, everything was done and ready to use within Obsidian, then the Neovim itch started, soon discovered there is an amazing plugin that let's you do plenty of actions you want from within our beloved editor with the ONE BIG CAVEAT that in order to sync the data (I actually pay for Sync as a way to appreciate the dev's work) you need to open up the application which kind of defeats the purpose of running your vault from your text editor.

Which led me to an amazing realization, Neovim is good but you shouldn't do everything on it.

Repeat after me. Not everything has to be done from Neovim.
— Miguel Valdes (@mr_mvaldes) January 14, 2026

Once that pill went through my system one afternoon which led to me crying myself to sleep that day, it eventual led me organize my vault within the application which tends to make people go into the rabbit hole that is spending more time organizing your vault instead of actually using it. Not gonna lie that hole became my prison for a week or two until the whole system finally clicked as I could use some plugins from the community and the base editor, mostly bases.

Bases are amazing

Before bases the organization and finding documents experience was a bit painful as my whole structure went through several productivity frameworks, from pure GTD to PARA and even a crazy one called Johny Decimal. In the end I have a mix of the frameworks that makes putting notes into a reliable and efficient system which greatly benefits from bases that allow me to visualize and see everything in the vault dashboard.

Having a set of standardized properties into different types of notes also help with an easy vault management and use, here are some examples on some of my bases for big projects I’m tracking.

Vault organization that mixes PARA, GTD and a bit of Johny-Decimal.
Dashboard using bases to see all of my tickets/tasks
How this blog is written and organized as well

Task management is still disappointing

One big aspect of dumping my entire life into Obsidian was organizing my tasks, which again Bases help out a lot but it is simply not the same.

I know there are several plugins that allow you to do task management within the tool, but I feel they lack some key features which are mandatory in my opinion in any task application:

Notifications
Repetitive tasks
Sub tasks
Calendar synchronization

For years I have used and paid for Todoist but after recent drama of focusing on AI features and price hikes seems like the company is focused on something that I simply don't like nor enjoy. So I'm trying to use a mix of Apple reminders and Obsidian.

Use of AI

We couldn't wrap this up without mentioning the ever increasing topic of AI within your vault, there are again a number of plugins available but a lot of people out there are simply using things like opencode or claude code to organize, update or review the contents on their vaults which is something that caught my attention, so of course I allowed AI into my notes to standardize couple things like:

Tag redundancy, went from 70 tags to 43
Missing properties in documents
Introduction and use of aliases to refer to topics easier

Another big aspect is that my vault is backed up as a git repository I can also run cron jobs using Github Actions + AI to create weekly reviews of my tasks or help me organize the inbox automatically while keeping my properties, tags and way of organizing consistent.

I know giving your entire life to AI isn't ideal but at least it's not reading my emails/calendar or chat history.... looking at you clawdbot users.

In the end, it doesn't even matter

Ultimately my Obsidian vault is something that will keep evolving and changing but couple things are here to stay:

Use of AI to organize and keep consistency, ideally make those interactions run within my environment so providers do not have my entire vault at their disposal.
Use Obsidian directly instead of patching things via Neovim
Keep trying to find the perfect balance and setup for task management while reducing the dependency on several apps for it

Hope you enjoyed it.
Adios 👋

Monitor your Claude usage

Miguel Valdes — Thu, 12 Feb 2026 17:16:35 +0000

Lately I've been using Anthropic Claude via their official CLI Claude Code a lot to manage and code basically everything in my life as the AI Overlords intended. One interesting (or annoying) feature is how quickly tokens get consumed, so I wanted to track my consumption patterns and understand my historical AI usage. While browsing Reddit posts on observability, found out that the official claude CLI actually exposes telemetry. Of course, I had to hook it up to my local SigNoz instance to see what it produces and visualize it.

Setup

To get this done it's pretty straightforward, enable or set some variables per session or in your favorite shell and done!. - see actual steps here
My variable setup looks like this.

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=http/json
export OTEL_EXPORTER_OTLP_ENDPOINT=http://otel.local.net

Do want to point out I already run an OTEL collector in a centralized location to receive all of the metrics/logs/traces from my various services/applications. If you want to setup yours, this is a nice guide on what it is, how it works and how to get it running.

Results

After looking at the metrics and logs it produced I came up with a simple dashboard that shows me the core results of my experience with the tool:

Cost
Token usage
Model usage
Input and Output Tokens
Average request duration

Next steps:

Setup an alert when the Cost is getting close to a limit.
Review how efficient my prompts are using the length and token usage.
Track which model gives me better results for the type of task I'm working with, now that i can have a breakdown of it's usage
Improve prompts to have a higher control on the number of output tokens

Yaml is King change my mind, please!

Miguel Valdes — Mon, 24 Nov 2025 16:19:41 +0000

Got a short one for you this week.

If you work in the “DevOps” field, by now you have used YAML to some extent in tools like Kubernetes, Docker Compose, or Ansible. How about some CI/CD like GitHub Actions? Maybe you are one of those psychopaths who write Terraform in either JSON or YAML—it should be illegal to do that, in my opinion.

Either way, you have seen YAML and maybe like it, maybe hate it, but we cannot deny the fact that it is king for a lot of tools out there, with JSON and TOML nearby, trying to take the spot.

Now, I’m on the middle ground. As much as YAML helped me when I started my career in Ansible and later on with Kubernetes—since it’s easy to write and understand—it’s ALSO a nightmare to work with because of its super helpful but stupid indentation rules. And while you might say, “Well, just use a formatter and stop crying…” Sure, crying is fun, but what if the formatter isn’t aware of the schema and suddenly puts that item at a different indentation level? Well, now we both cry together, and that is beautiful!

You may know that I use Neovim (btw), so even with a formatter and a great LSP + linter, it all becomes useless if you start spewing out random YAML files. So, it is imperative that your editor is aware of your schema and what goes where, which is why things like schemastore help out a lot when working with these filetypes. A bit ironic, as the SchemaStore project is mostly for JSON, but we can all live happily together.

Setting up a good workflow is not exactly easy—a lot of manual intervention is still required. Maybe other editors do a better job. If they do, please let me know, as I use YAML a lot!

So what alternatives do we have? Glad you asked.

Cue: A great open-source language that can generate and validate files to be turned into other formats like YAML.
JSON: Yes, it’s probably easier to write since there’s no indentation, with the caveat of a ton of quotes around keys, but that might be better in the long run. You can always use a tool to transpile it to YAML.
HCL: As a Terraform enjoyer, I like the language and find it easy to understand, with the constraint that it’s mostly used in HashiCorp tooling, so it’s a bit restrictive.
TOML: Haven’t used it much, so nothing to say here, but I know it’s a good alternative. Whatever you end up picking, remember there are tools out there to help make it easier to work with, like yj.

YAML is King. Change my mind, please!

Adios 👋

Golang Interfaces are easy

Miguel Valdes — Wed, 17 Sep 2025 14:34:03 +0000

Recently been doing a lot of Interfaces for my twitch bot (I stream btw, rarely but I do). So while setting up the web-server I wanted to customize some of the functionality so each request checks the headers and respond differently based on said headers. So I went down the rabbit hole into Middleware and based on a book I’m reading called “Let’s Go” by Alex Edwards you can pretty much “overload” the default methods as long as it satisfies the interface.

So wtf is an interface?

It’s basically a definition of something that contains functions/variables/parameters and those must exist and return/do what the interface demands.

The definition is: A contract that has to be followed.
For those of us who are 5: Either it does what the interface says or it won’t work and it doesn’t care how you do it.

So let’s check a very minimal example of that same task I’m working on. Here’s the breakdown of the flow.

A request is received on an endpoint
Request is passed to a handler
Check the request headers and do something based on that
Return response to user

So what is the interface for an http handler?

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

We will require a function that satisfies that interface, aka a function that accepts a Writer and a Request, those 2 are interfaces on their own but we won’t go into them.

// Our Custom Handler
type customHandler struct {
    HeaderCheck string  
}

func (c *customHandler) ServeHTTP(w http.ResponseWritter, r *http.Request) {
    if _, ok := r.Header[c.HeaderCheck]; ok {
        w.Write([]byte("Found your header value here"))
    }
}

// The main declaration for our webserver
func main(){
    mux := http.NewServerMux()
    custom := customHandler{HeatherCheck: "subscription"}
    mux.Handle("/", custom)
    http.ListenAndServe(":3000", mux)
}

So what did we do?

A struct was created with a simple string field that will be used to validate
A function was done on that struct that satisfies the interface
The handle function is happy with our handler as it has a method ServeHTTP which is the interface of type Handler
Web-server works as intended, when a header that has a key value “subscription” comes up our server will respond to the user

➜  curl localhost:3000 -H 'subscription: true'
Found your header value here

Now that’s pretty much how interfaces work. They allow you to grab existing behavior to let you add more functionality to it. In your golang journey you will find them pretty often and they are very common in some of the regular operations like opening files/buffers, reading data from a location or working with web servers like we saw above.

Conclusion like I’m 5

It’s like making a piece of a puzzle match a missing slot
Interfaces are ways to let you customize how things work as long as you follow the basic rules.
You will use them without knowing as they are cooked within everyday functions and libraries
Each interface you do must be a function of a something, most of the times it will be a struct which can be empty or have 0 fields as long as it can do the function the interface dictates.

Hope this helps you as interfaces was the one concept that completely made no sense in my head until I had to actually use one to change the behavior of something.

Adios 👋

Why Self-Hosting made me a better engineer

Miguel Valdes — Mon, 08 Sep 2025 17:04:30 +0000

It is a fact that people who are passionate about a topic or subject tend to know more or do better at said topics, so in the case of Software Engineers you probably have run into couple different types of engineers, which in my humble opinion (based on working in the industry for 12 years now); These are the 3 big “types”:

The guy who studied CS since it paid good and just work the 9-5. Extra hours probably spent touching grass.
The guy who went to CS because he just loves and is passionate about code and everything around it. Most likely works and maintains some open source projects on their downtime. Spends his time arguing over a language or framework on X or Twitter.
The self-taught who ended up in tech and comes from an unrelated tech background (nurse, musician, etc.) and is obsessed with it and somehow turns his entire personality and life into tech. Some are crazy enough that build an entire data center in the basement or closet.

That being said I’d consider myself type 3 as I never did CS at school and everything I know comes from experience and passion.

Some of my big learning experiences that make me stand out vs other engineers at work are the following:

NOTE: This is of course very Ops based, since that’s where I started my career in tech.

Had to learn an amazing amount of information in order to even get the Homelab usable, from installing the OS to setting up the additional drives and mount points… Setting up a secure SSH configuration, users and credentials, permissions on files, etc.
Setting up the entire Networking, this one was huge for me as it helped me a TON to grasps concepts of DNS, TCP, iptables, ports/firewalls, etc. This one skill has made me surpass a lot of my fellow engineers at work, understanding how things are connected and work just changes your perspective. Suddenly everything clicks in your head.
Installing things, which at first were done manually but once you start adding more machines or services the manual steps become boring, repetitive and error-prone, we are humans, so we tend to screw those up. So tools like Ansible or Chef stated to appeal to me, so my machines could have the exact same configuration over and over.
Containers disrupted my entire way of thinking and running things, so I learned how Docker works and how I could customize my own images and services. This got worse when my Homelab expanded, so I needed to run more containers in the machines so my good ol’ network knowledge was useful at understand how those bridges were formed between nodes.
Eventually the hot thing was Kubernetes, the migration was painful and full of new concepts and way of doing things, but I feel comfortable now transforming any docker-compose with whatever number of services and containers into Kubernetes manifests.
With the complexity of the manifests tools like Helm Charts or Kustomize became another skill I had to learn, this one was somewhat easy since its just abstractions over manifests.
Storage became important so a NAS was acquired and with my knowledge it was easy to set up and start generating some Volume Claims for my own needs.
Network went from a basic Netgear router to a full blow installation consisting of:
- Unifi Dream Machine
- Unifi PoE Switches
- Unifi Wi-Fi Access Points
These devices introduced me into the work of proper networking where you have control over DNS, VLANs, Firewall Policies and actual useful telemetry of what is going on in the network. This part was also the most expensive one so far as those devices aren’t exactly cheap.
As my workloads became part of the entire family routine without them knowing, things needed to become accessible from in and outside our home. This is when things like Tailscale and Cloudflare tunnels became important. Everything that I paid for became a service I could self-host within my lab so the more things I ran, having availability and good monitoring became critical. To point out it’s what I do at work so, this became an excellent playground for me to test different technologies without causing outages. This is probably the main reason why this whole thing started, I wanted a safe environment to test and break without disrupting anyone but myself.
Having the playground enabled me to learn how things are built; I started to learn coding and doing the usual dumb apps, turning them into containers and finally deploying them. Great way to see the full deployment lifecycle, nowadays people rely on other engineers or services to do this which is OK, not everyone needs to learn the tech and master it, but it’s somewhat important to know what’s going on behind the scenes IMO.

Again these are very Ops based which is funny because I built this entire thing to allow myself to learn to code and deploy somewhere end to end, Devops some people call it. That was the original motivation, not building and running on my local machine something that I could rely on or use outside my personal computer, from a little Raspberry Pi running a dumb container and a DNS server to an entire rack with couple machines and enterprise grade network devices.

Now this is an overkill and probably steered into a non so coding arc, but I’ve found that is what I’m passionate about, systems and how to set them up, figuring out how to configure software and make it reliable and easy to monitor effectively.

Hopefully this helps someone realize that not everything in Software Engineering is coding and being on top of the latest language or framework. Without the infra and people running it even on cloud it all becomes pointless. Yes even those serverless functions require servers my dudes LOL.

See you on the next one. Adios 👋

Chef Tips and Tricks

Miguel Valdes — Mon, 08 Sep 2025 16:56:08 +0000

Lately I’ve been pretty deep into the Chef weeds and the more I end up working on it, the more I keep finding these little tips and tricks on how to get something done, some of these come from Seniors that passed them on to me and some of them I either end up finding online or figuring them out so would like to share them in case someone finds them useful.

Need to run a command and use the output for something?

There is the execute or ruby_block resources but what if you need the output of something to determine if a resource should run or not?. Maybe its a guard for another resource in your recipe, simple, use the mixlib/shellout library. Should be installed since it’s part of Chef SDK.

require 'mixlib/shellout'
find = Mixlib::ShellOut.new("find . -name '*.rb'")
find.run_command

 # Grab the output either good or bad
puts find.stdout
puts find.stderr

Copy a local cookbook to a node with chef installed

If you ever need to see how your cookbook will be applied to a machine but you are not ready yet to push it out to your chef server?. I gotchu, you can simply zip the entire cookbook and copy it over to a node and then apply a new runlist!.

Copy the tarball and put it somewhere
Modify the client.rb to point to a directory holding the cookbooks (it must contain the metadata.rb)
Edit the client.rb so it fetches from a local path, the cache location is a good spot since it already has your cookbooks.

cookbook_path    /var/cinc/cache/cookbooks

Run cinc client in solo mode and specify the runlist, it is important you run this with -z so its done in solo mode. Meaning it won’t reach out to the chef server to fetch data.

cinc-client -z -r "yourcookbook::recipe"

Your cookbook should now be applied to the instance, hack away!

Test a resource before putting it in a cookbook

In a node with cinc installed you can enter into the shell and go inside recipe_mode to test out resources. If you are happy with them you can later run run_chef to actually execute them against a node. This is great to test and design cookbooks.

cinc-shell -s

cinc (17.9.26)> recipe_mode
cinc:recipe > git '/tmp/dotfiles' do
cinc:recipe >   repository 'https://github.com/mvaldes14/dotfiles.git'
cinc:recipe (17.9.26)> end
 => <git[/tmp/dotfiles] @name: "/tmp/dotfiles" @before: nil @params: {} @provider: nil @allowed_actions: [:nothing, :sync, :checkout, :export, :diff, :log] @action: [:sync] @updated: false @updated_by_last_action: false @source_line: "(irb#1):1:in `<main>'" @guard_interpreter: nil @default_guard_interpreter: :default @elapsed_time: 0 @declared_type: :git @cookbook_name: nil @recipe_name: nil @repository: "https://github.com/mvaldes14/dotfiles.git">
cinc:recipe (17.9.26)> run_chef
[2022-10-12T20:56:21-05:00] INFO: Processing git[/tmp/dotfiles] action sync ((irb#1) line 1)
[2022-10-12T20:56:22-05:00] INFO: git[/tmp/dotfiles] cloning repo https://github.com/mvaldes14/dotfiles.git to /tmp/dotfiles
[2022-10-12T20:56:23-05:00] INFO: git[/tmp/dotfiles] checked out reference: 5c362e70aaa0c51055df0c7015582d89ab3e1017
 => true

See attributes on instance

This is useful to debug if an attribute does not behave as you expected or if you have a lot of overrides and don’t know which one is the final one being kept. Also helpful in case ohai replaces something you were expecting.

If its in a kitchen converge do

cd /tmp/kitchen
cinc-shell -c client.rb -j dna.json
node['attribute']

If it is an already bootstraped instance then

cinc-shell -z
node['attribute']

Run systemd inside of test kitchen with dokken

This is pretty useful if you are not using vagrant to test out your kitchen instances and prefer something quicker like Docker, which works great except when you need to interact with systemd to actually start/enable a service you just installed. For those scenarios you can simply pass or mount part of your cgroups so systemd runs inside the container.

NOTE: This only applies if you are using NIX as the base machine to develop your cookbooks, for other OS I honestly have no clue… maybe just use vagrant.

Your kitchen.yml should looks something like this.

driver:
  name: dokken

transport:
  name: dokken

provisioner:
  name: dokken

verifier:
  name: inspec

platforms:
  - name: centos-7
    driver:
      image: centos:7
      privileged: true
      pid_one_command: /usr/lib/systemd/systemd
      volume:
        - /sys/fs/cgroup:/sys/fs/cgroup:ro

Those are some of my most precious tips so hopefully they serve you well.

If you got more tips on how to do magic things in Chef please do let me know so I can learn and include them into my blogs and wikis!.

Until the next one, adios 👋

Split Keyboards are fun!

Miguel Valdes — Mon, 01 Sep 2025 18:10:21 +0000

It’s been 3 months or so now from when my journey into the split keyboards started and I blame my old cheap self and tech twitter who once again managed to “influence” me into buying things I probably should’ve acquired a long time ago.

I’m not exactly a coder that is writing non-stop for hours like some of you might be, but I do type a lot to communicate over Slack and also I’m probably the top person on my team doing documentation and updates on playbooks or notes, so over time I started to develop stiffness on my wrists after a good session at work. Always imagined it would take me couple more years to reach the stage of having physical pain at work (emotional pain is always there).So after watching streams, YouTube videos and countless posts on tech twitter about how split keyboards were the #1 thing people recommend you get if you want to make it into the world while also preventing a lot of pain down the road, it was my time to join the club.

So as a birthday excuse my wife insisted on buying something “nice”, so I pulled the trigger and ordered a ZSA Moonlander MK I. Which covers some of my requirements:

It’s split duh!
Customizable keycaps and switches
Can be programmed to do a bunch of things
Has RGB - yes I’m pathetic like that!
Extras can be either printed or bought directly from the vendor
Looks awesome, it just does.

Not going to lie the first days I couldn’t even type more than 4-7 words per minute because everything was confusing. I had to keep looking at the keys, so I could narrow down which keys to hit. Also, idiot me decided to buy the version with blank keycaps so my pain and frustration levels went through the roof, thankfully I had some spare keycaps from my Razer Gaming Keyboards and those worked while I settled into things.

Another big time consumer item I wasn’t truly expecting was finding or setting up the keys into locations I could easily find, remember and benefit from. Spent couple hours just flashing over and over the board cause realized I either couldn’t find a key or it was on a location that made no sense to me. Eventually I found my silver bullet configuration which you can see here.

Overall it took me 1.5 months to get back into my average words per minute (90-105) with minimal errors. Also, those long documentation or blog writing sessions no longer cause problems.

Finally, my setup just looks awesome with the split keyboard. I’m really happy with my purchase.

TLDR - Yes the keyboards are expensive but, they are awesome, fun and help you a ton in the long run.

Until the next one! Adios 👋