DEV Community: Dennis Lemm

My personal Voight-Kampff Test

Dennis Lemm — Wed, 08 Apr 2026 00:00:00 +0000

After March MadCSS I started to challenge myself in CSS Battles and found out - it's my personal Voight-Kampff Test. And I love it.

Lately I developed the habit of taking my own personal Voight-Kampff Test. But I am not answering one of these LAPD questions:

You're given a calfskin wallet on your birthday.

Nah, I don't answer questions. I push pixels. It has started with the phenomenal March MadCSS tournament by Syntax. I watched the first round and thought: Watching my favorite CSS enthusiasts also struggling to center a div (under a lot of pressure) was fun. And kind of far away from my current work life. I wanted to write more CSS again (for weeks, or months(!) actually). I suddenly remembered CSS Battle and so it began.
I have solved almost every daily challenge since. I skipped one or two because of birthday preps or something similar.

So why do I call these fun little exercises and code golf challenges my Voight-Kampff test? I solved them and wanted to ask Claude and ChatGPT if I could tweak them a little bit more. The answers have been hilariously wrong. Every dang time. Written with such confidence that you question everything they spit out. It's so refreshing.

And I seem not to be the only one testing it. Obviously. This was a comment from the CSS Battle Bluesky Account on my post:

CSSBattle is infact that! No bot has been able to golf solutions correctly until now...

So if you feel unsure if you are a bot/replicant or not. Or your vibe coding session has been a little bit too long. Give it a try. My current solution has 240 characters. Not perfect, but not bad either. And of course 100% self-golfed. For the fun.

These are my funniest top 3 AI "improvements" so far:

Use aspect-ratio:1 instead of height:250
Add these three elements with pseudo-elements...
Can you remove this oddly specific line of styling?

After some frustrating "tips" I told it I will do it on my own:

Fair enough 😄 CSS Code Golf is really a discipline where I’m more of a guesser than a helper—there’s just too much implicit knowledge about CSS quirks, browser parsing peculiarities, and visual pixel-perfect accuracy that I can’t verify.

And the learning is: AI is the guesser. Always. Keep that in mind.

This post was first published here: lemm.dev

Ai-lone

Dennis Lemm — Tue, 17 Mar 2026 00:00:00 +0000

A sentence from Salma Alam-Naylor about AI and loneliness hits close to home. On remote work, vanishing office culture, and what we lose when we replace colleagues with agents.

There’s this one sentence from Salma Alam-Naylor’s Blog Post that really fascinates me:

AI is an incredibly lonely experience where human collaboration and conversation have been replaced by strange conversations with computer algorithms.

That sentence hits the nail on the head for me — and it leaves behind a deep sadness. This loneliness at work started for me with the pandemic. And yes, I love working from home. Especially as a parent, it’s a blessing not to be away from home for eleven hours a day — to witness a lot, or even most, of your child growing up. When you’re trying to share parenting and partnership as equals, it also means the other parent can occasionally tap out and catch their breath.

At the same time, I find myself holding on to a work reality that was shaped by coding together, solving problems together — and yes, the occasional Nerf gun battle or foosball game was a welcome break for passively mulling over a bug, which back at your desk would often get solved pretty quickly. But even when it didn’t, there were always colleagues in the office who could help. Now, with AI being practically omnipresent, it somehow feels even worse. Even in the office, it has become quiet and lonely. And a sentence from a colleague describes that feeling just as perfectly as Salma did:

So I just discussed the best solution to the problem with my agent.

Where we used to ask a colleague, we now ask an agent — or even four, five sub-agents. Sure, that buys our colleague some time, sparing them from being pulled out of their context to deal with our problem. But what gets lost? Our own problem-solving skills. And the connection to our colleagues. That shared moment of triumph when the div is finally centered. The code works and the linter stops complaining.

Or simply that a colleague might not have an answer right away either. That you’re not alone in that brief moment of not knowing. That won’t happen with AI. It always has something to say — immediately, confidently, even when it’s wrong.

Ask a colleague again. Pull them out of their context. It’s worth it — for both of you.

Originally published at lemm.dev

Mastering Git Cherry-Pick: Advanced Guide with Real-World Examples

Dennis Lemm — Tue, 08 Oct 2024 09:57:32 +0000

What I love about being a web developer is that you never know what challenges the day might bring. Today, I encountered a problem that was fairly new to me. On a large project with many developers working on the same codebase, we needed to ship a specific feature. But we hadn't released in two weeks, and many changes were queued for deployment to production, though they hadn't been fully tested yet. So, what could we do? Enter git cherry-pick for the rescue.

The git cherry-pick command provides a precise solution, allowing developers to extract and apply only the necessary commits without merging untested changes. In this article, we'll explore git cherry-pick in detail, covering its applications, best practices, advanced strategies, and key parameters with practical examples for advanced users.

TL;DR

The git cherry-pick command allows developers to selectively apply specific commits from one branch to another without merging all changes. This guide covers:

How to use git cherry-pick: Step-by-step examples on applying individual commits, resolving conflicts, and managing multiple commits.
Key parameters: Using --no-commit, -x, and handling conflicts with --continue, --abort, and --skip.
Related Git commands: Comparisons with git merge, git rebase, git revert, and git reset.
Best practices: Ideal use cases for hotfixes and selective commits, along with situations where cherry-picking should be avoided.

For developers dealing with large-scale projects or urgent fixes, it cherry-pick is a powerful tool for keeping your workflow clean and efficient.

What Is Git Cherry-Pick? A Deep Dive

The git cherry-pick command lets you select and apply changes from a specific commit in one branch to another. Unlike git merge or git rebase, git cherry-pick applies only targeted commits, helping maintain a clean and focused repository history.

Like in my situation where I had made some changes that needs to be shipped but team mates made a lot of changes to the develop branch as well. So we needed one feature, but we didn't want to incorporate unrelated changes from the other teams. Instead of shipping the whole branch, we created a hot fix branch and used git cherry-pick to extract just the needed commits.

Real-Life Application of Git Cherry-Pick

Let's walk through what we did to ship the feature to production - a practical example to understand how git cherry-pick works:

Scenario

As mentioned above, imagine you're developing a new feature that got merged into the main branch that is waiting to be deployed to production. Other teams are developing into this branch as well. For example improvements for other parts of the code base. Due to some delays in the testing workflow you got stuck but you need to deploy this one feature or perhaps a critical bug fix.

Steps to Cherry-Pick

1) Switch to the branch with the commit
First, switch to, in this case, main branch to locate the commit you need:

git checkout main

2) List recent commits to identify the one you need
Run the following command to see a log of recent commits:

git log --oneline

3) Switch back to the target branch
After identifying the relevant commit hash, switch back to your hot-fix-branch:

git checkout hot-fix

4) Apply the commit using cherry-pick
Use git cherry-pick followed by the commit hash to bring in just that needed change:

git cherry-pick <commit-hash>

Explanation: This applies only the specified commit to your current branch without pulling in other changes from main. Git applies the diff from that specific commit, preserving the commit history only for that change.

Handling More Complex Projects

In larger projects, where multiple developers contribute to different branches simultaneously, cherry-picking becomes particularly useful for handling emergency fixes.

Cherry-Picking Across Forked Repositories

When working with forked repositories, you may find yourself cherry-picking changes from the upstream repository into your fork. This allows you to pull in specific commits from the parent project while avoiding conflicts with your own local work.

For example, you might cherry-pick a security patch from the upstream repo:

git fetch upstream
git cherry-pick <commit-hash>

Explanation: This command fetches the latest changes from the upstream repository and applies only the selected commit to your local branch. It's especially useful when contributing to open-source projects where you need to stay updated with upstream changes without merging everything.

How to Find the Right Commits with Git Log

A critical part of using git cherry-pick effectively is identifying the correct commits. Here are some tips for filtering and selecting relevant changes:

View Recent Commits

To list recent commits, you can use this command to view commits from the past two weeks:

git log --since="2 weeks ago"

You can adjust the --since parameter to narrow or expand the timeframe.

Filter by Author

To search for commits made by a specific author:

git log --author="Author Name"

This helped me a lot, because I know that only my changes had to be cherry-picked to the hot-fix-branch.

Cherry-Picking Multiple Commits

Once you've identified the commits, you also can cherry-pick multiple commits at once:

git cherry-pick <commit-hash1> <commit-hash2>

This command applies multiple targeted changes to your branch.

Cherry-Picking a Range of Commits

To cherry-pick a range of commits by specifying their hashes:

git cherry-pick <commit-hash1>^..<commit-hash3>

This will apply all commits between commit-hash1 and commit-hash3.

Advanced Git Cherry-Pick Parameters

git cherry-pick offers several advanced options to tailor its behavior to your needs:

-n or --no-commit: Applies the changes without committing them. This lets you make further modifications or combine multiple cherry-picked commits before committing.

git cherry-pick -n <commit-hash>

-x: Adds a reference to the original commit in the new commit message, which is helpful for tracking the lineage of changes across branches.

git cherry-pick -x <commit-hash>

--continue: If you encounter a conflict and resolve it manually, use this command to continue the cherry-pick operation after resolving the conflicts.

git cherry-pick --continue

--abort: Cancels the cherry-pick operation and discards any changes applied so far, which is especially useful if the conflicts become too difficult to resolve.

git cherry-pick --abort

--skip: If a conflict arises and you want to skip the conflicting commit, use this option to bypass the commit and continue the cherry-pick process.

git cherry-pick --skip

Related Git Commands and When to Use Them

While git cherry-pick is great for selective commit application, it's important to understand how it compares to other Git commands:

git merge: Use this to combine branches entirely. It's better for large-scale integrations but brings in all changes from one branch into another.
git rebase: Allows you to rewrite the commit history by applying changes on top of another branch. This is useful when you want to maintain a linear history.
git revert: Unlike git cherry-pick, this undoes a specific commit by creating a new commit that reverses the changes.
git reset: Resets your branch to a previous state. Use this if you need to discard commits altogether, which differs from cherry-picking's selective nature.

Practical Considerations for Cherry-Picking

Handling Conflicts:
Conflicts often arise if both branches modify the same line of code differently. When this happens, Git halts the cherry-pick process and prompts you to resolve the conflict. Once you've resolved it, continue with:

git cherry-pick --continue

If the conflicts are too complex to resolve, you can cancel the entire operation using:

git cherry-pick --abort

When Not to Cherry-Pick:
Cherry-picking should be used carefully. Overuse can lead to a fragmented commit history, especially if multiple developers cherry-pick the same commits into different branches. In some cases, git merge or git rebase may offer a cleaner solution for integrating changes across branches.

Best Scenarios for Cherry-Pick Usage

Ideal Use Cases:
Applying hotfixes across multiple branches when only specific changes are required.
Extracting particular commits from a feature branch without merging the entire set of changes.

When to Avoid Cherry-Picking:
For large-scale integrations, git merge or git rebase often provide a more consistent approach.
When branches have diverged significantly, cherry-picking can lead to complex conflicts and inconsistencies.

Leveraging Git Cherry-Pick in Collaborative Environments

In team environments, communication is key when cherry-picking commits. Ensure team members are aware of which commits have been cherry-picked and why. If multiple branches need the same fix, consider creating a shared branch for merging, which reduces redundancy and ensures consistency across the team's work.

Conclusion

git cherry-pick is a powerful tool for selectively applying changes without merging entire branches. When used carefully, it keeps workflows streamlined and project histories clean. However, be mindful of when and how you use it to avoid introducing unnecessary complexity.

Have you used git cherry-pick in your projects? I'd love to hear about your experience! What challenges or successes have you encountered when using it? Additionally, if you're interested in more articles on advanced Git commands, let me know-perhaps a series is in order!

Breaking the Code: My Journey from VS Code to NeoVim

Dennis Lemm — Fri, 23 Aug 2024 20:06:32 +0000

In over almost a decade of web development, I've navigated through countless tools that have defined our industry. From my early days using Dreamweaver to the refined elegance of VS Code, I’ve tried them all. Almost.

Like many of you, I found comfort in the familiar, in the tools that promised to make my workflow smoother, faster, and more efficient. But recently, something changed. I discovered NeoVim — a tool I had long ignored, dismissing it as an ancient relic, out of place in the modern world of sleek, GUI-based IDEs.

And yet, here I am, writing this article in NeoVim, wondering how I didn’t make this switch sooner.

The Comfort Zone: Working in VS Code

Let’s be honest: VS Code is a fantastic editor. With its vast extension marketplace, user-friendly interface, and powerful features, it’s no surprise that it has become the go-to IDE for many developers. For years, I fine-tuned my VS Code setup—theme, extensions, keybindings—all designed to maximize my productivity. It felt like home, and I was comfortable. Yet, comfort can sometimes breed complacency, and I soon found myself questioning whether there was a better way.

But comfort can sometimes lead to complacency. While VS Code provided everything I needed on the surface, I started to notice the friction points—small inefficiencies that added up over time. The occasional sluggishness when loading large projects, the endless mouse clicks, and the constant context-switching between code and mouse started to wear on me.

A Reluctant Encounter: My First Brush with VIM

Like many developers, my first encounter with VIM was accidental, and it wasn’t love at first sight. I remember the panic of trying to close a file, furiously searching for a way out like a trapped animal. Esc :q! became my mantra, a quick fix that let me escape unscathed, but the experience left a sour taste in my mouth. Why would anyone willingly use this?

I avoided VIM so much that I even had a meme as my desktop background that perfectly captured the absurdity of the challenge of closing VIM. It was inspired by the movie Arrival, where Amy Adams' character, linguist Louise Banks, holds up a sign that says Esc :q!. The meme perfectly captured my frustration and the absurdity of my struggle with VIM. For years, it served as both a joke and a warning: 'Proceed with caution—this editor isn't for the faint of heart.'

The Turning Point: A New Perspective

It wasn’t until a colleague mentioned that he had switched to NeoVim that I began to reconsider. "You can be so much faster," he said, "once you get used to it." Faster? I was intrigued. Speed has always been the name of the game in development. Could NeoVim really offer something that VS Code couldn’t?

Around the same time, I stumbled upon a YouTube video by ThePrimeagen, where he demonstrated his lightning-fast workflow using VIM motions. Watching him fly through his code with precision and speed, I began to see the potential. Maybe, just maybe, I had been missing out on something all along.

The Gateway Plugin: VSCodeVim

To start my vim experience in my comfort zone I installed the VSCodeVim extension, and my descent into the rabbit hole began.

After three weeks in VSCode I decided to give NeoVim in the terminal a fair shot. Installation was straightforward. On macOS, a simple brew install neovim got me up and running. But it was clear that NeoVim wasn’t just a tool you install and start using; it’s a tool you shape, mold, and configure to fit your workflow like a well-tailored suit.

After a short chat with my colleague I began with NvChad, a preconfigured setup that promised a modern UI and essential plugins. It provided a solid foundation, but the real magic happened when I started customizing it to suit my needs.

Now, after ten days of working exclusively in the terminal with NeoVim, I find it hard to believe it’s me embracing this change. And it's so much fun! Who could have thought.

This VIM-emulating extension for VS Code, which Microsoft probably should ban, has led me to not want to use VS Code at all anymore.

The Learning Curve: From Frustration to Mastery

I won’t sugarcoat it — learning NeoVim was and still is challenging. My muscle memory, honed over years of using VS Code, fought me every step of the way. The first few days were a frustrating mix of excitement and regret. But with each small victory—learning to navigate without a mouse, mastering basic commands, and configuring keymaps — I felt a growing sense of empowerment.

NeoVim isn’t just an editor; it’s a way of thinking about code. It forces you to slow down, to be deliberate in your actions. And paradoxically, this deliberate approach ultimately leads to greater speed and efficiency.

Why NeoVim? The Unseen Advantages

So, what does NeoVim offer that other editors don’t? The answer lies in its philosophy and design:

Speed and Efficiency: NeoVim is built for keyboard navigation. Once you’ve internalized its commands and motions, you can move through your code faster than ever before. The lack of reliance on a mouse means fewer context switches and a more focused workflow.
Customization: With NeoVim, you’re in control. From keybindings to plugins, everything is customizable to fit your exact needs. The inclusion of Lua scripting for configuration offers a level of flexibility that’s hard to match.
Lightweight and Fast: Unlike many modern IDEs, NeoVim is incredibly lightweight. It opens instantly, even with large projects, and never bogs down your system.
Extensibility: The plugin ecosystem around NeoVim is vast and active. Plugins like telescope.nvim for fuzzy finding, nvim-lspconfig for language server protocol support, and treesitter for advanced syntax highlighting elevate NeoVim to a level of functionality that rivals, and often surpasses, other IDEs.

My Setup: A NeoVim Configuration for Web Developers

For those interested in making the switch, here’s a glimpse into my current/starter NeoVim setup:

Plugins: I rely on telescope.nvim for file and text searching, nvim-lspconfig for robust language support, and treesitter for syntax highlighting. I’ve also added fzf for a blazing-fast file finder and prettier for automatic code formatting.
Keymaps: I’ve remapped jk to Esc, which makes exiting insert mode quicker. Or using the vs code familiar moving entire lines by just type in J or K. And some other minor changes.
These simple changes have already made my workflow more fluid. What's in your keymap? I'd love to hear about your configurations in the comments.
Custom Commands: I’ve created a few custom commands to streamline repetitive tasks, like quickly creating a new buffer or searching across files with a single keystroke.

The Verdict: NeoVim Is Worth the Effort

After several days of using NeoVim exclusively, I can confidently say that it has been a game-changer. It’s not just about speed — though that’s a big part of it — it’s about a deeper connection with my code. The minimalistic, distraction-free environment of NeoVim allows me to focus entirely on the task at hand.

Switching from a full-featured IDE like VS Code to a terminal-based editor like NeoVim might seem daunting, but the rewards are well worth the effort. If you’re looking for a tool that will push you to be a better, more efficient developer, NeoVim is the rabbit hole worth diving into.

Ready to Make the Switch?

If you’re curious about NeoVim, I encourage you to take the plunge. Start small with a basic setup, and you'll soon discover how it can elevate your development workflow to new heights. The learning curve may be steep, but trust me — the view from the top is worth every step.

Have you made the switch to NeoVim? Share your experience in the comments — I'd love to hear how it’s transformed your workflow.

The Next Chapter: Transforming My Obsidian Setup with Vim

As I’ve delved deeper into the world of Vim, I’ve realized that its principles of efficiency and keyboard-centric navigation extend beyond just coding. Inspired by my success with NeoVim, I’ve started transforming my entire workflow to embrace Vim’s philosophy, starting with my note-taking and knowledge management tool: Obsidian.

For those unfamiliar, Obsidian is a powerful, markdown-based tool that I’ve relied on for organizing my thoughts, ideas, and project notes. It’s highly customizable, and naturally, I began to wonder — could I bring the same Vim-powered efficiency to Obsidian?

The answer, of course, is yes. Obsidian’s support for Vim keybindings has allowed me to create a seamless, consistent experience across all my tools. Now, whether I’m coding in NeoVim or jotting down ideas in Obsidian, my workflow remains fluid and uninterrupted.

In my next article, I’ll dive into the specifics of how I’ve configured Obsidian to match my Vim setup, sharing tips and tricks that have made my note-taking process faster and more intuitive. If you’ve ever wanted to unify your digital environment under the banner of Vim, stay tuned — I’m excited to share what I’ve learned.