Finish Things

In Lean, there's a lot of talk about reducing work in progress (WIP). It's interesting to me that even though it seems that Lean concepts have permeated the software industry, so many teams struggle with finishing things.

Speaking from the point of view of a developer, I can say that there's a real drag on morale when it feels like no one particularly cares about receiving the value of my work. Obvious bottlenecks in a team's process that persistently go unaddressed are not just a waste of money, they're a reason for people to check out. Add to this malaise the tedium of fixing the continuous merge conflicts that come when we create code branches that we can't merge for a long time. Ugh.

Some common impediments to finishing things:

  • Slow code reviews
  • Exhaustive manual testing
  • Distracted product owners

Slow code reviews

I've long been of the opinion that most code reviews are hardly worth the time spent on them by the reviewer and not worth the interruption to the flow of work that they cause. It's really hard to do good code reviews and it's a major bummer to wait a long time for someone to review your code only to get a rubber stamp. I like to call this "Quality Theater", where a checklist of procedures are half-heartedly (yet religiously) performed that don't actually improve the quality much. I would encourage teams to look at metrics in whichever code review system they use to see how long code reviews are taking, and how many significant changes to code occur as a result of the reviews. Be honest if they're resulting in long delays that usually end in a rubber stamp.

Exhaustive manual testing

If the team has dedicated QA people, is it taking a long time for work to make it through testing? Why? Is there a large amount of manual testing going on for every story? Can we automate more of the tests? Are stories hanging around in the "QA in Progress" stage waiting for clarification from the product owner about an edge case that's not really central to the story? Are stories being rejected by QA because of a small issue that does not detract from the value of the story?

Distracted product owners

Is the product owner plugged into the project fully and making it a priority? Are we waiting a long time for them to accept the work we've done? Are stories being held up because of ambiguous requirements where the team can't agree if they were met or not?

So how do we finish things faster? Other than recognizing the impediments above and having some earnest discussions about why they're occurring, there are some general concepts that apply broadly.

The common thread is in identifying what is our unit of "done"?

  • Make stories that are small increments of value
  • If a story is being held up because of a tricky aspect, consider splitting off the hard part and finishing the easier part cleanly
  • If we discover a story has a subset of the requirements that is contentious or poorly defined, can we finish the obvious part now and put a story in the backlog for the wishy-washy part?

The idea is to focus on finishing things. What is slowing down our process of getting units of value to "done"?

Challenging the Pull Request Orthodoxy

A thread showed up in my Twitter feed the other day from Dragan Stepanović about the low efficiency of pull requests for small changes and refactorings.

I think we've all felt that hesitancy to refactor something because it didn't seem valuable enough to push through a whole pull request approval process.

In the comments on Dragan's thread, someone mentioned an article on Martin Fowler's blog called Ship / Show / Ask. The author, Rouan Wilsenach, proposes that instead of requiring every change to be approved before it can be merged into the mainline, we can decide on a case-by-case basis whether to Ship (merge with no discussion), Show (merge and then discuss), or Ask (discuss and then merge).

My experience on teams that use pull requests has always been that every change follows the Ask path. For any change, no matter what it is, we submit a pull request, it has to be approved by one or more other developers, and only then can it be merged. But this process is not really worth the trouble and delay for some changes, depending on context such as who made the change, how much the change is like other changes that have been made many times, and where the change has been made.

As Rouan explains, some good candidates for the Ship option are things like:

  • I added a feature using an established pattern
  • I fixed an unremarkable bug
  • I updated documentation
Some candidates for the Show option would be:

  • I would love your feedback on how this code could be better
  • Look at this new approach or pattern I used
  • What an interesting bug! Look how I fixed it
Finally, the Ask option (a traditional pull request) could be reserved for things like:
  • Will this work?
  • How do we feel about this new approach?
  • I need help to make this better please
Always going with the Ask option, as most teams do, has some downsides that can be avoided with this more flexible model, as the articles explains:
The unavoidable thing about waiting for approval is that it takes time. If too many changes are in the queue for feedback, either the quality of the feedback goes down or progress slows down. 
The reason you’re reliant on a lot of “Asking” might be that you have trust issues. “All changes must be approved” or “Every pull request needs 2 reviewers” are common policies, but they show a lack of trust in the development team.
Pull requests are a great tool for modern software development, especially when contrasted with a free-for-all approach where nothing is reviewed. But it's important to remember that they're not necessarily appropriate for all situations.

Methodologies Are Descriptive, Not Prescriptive

In all my years in the software industry, I've never seen a team where I would say the methodology they professed to use actually mattered.

The siren song of methodology is that you can take a poorly functioning software development team, "install" a name brand methodology, and they will turn into a highly functioning team.

The way a new methodology is minted is a person or group of people with experience in the software industry decide to write down the characteristics, philosophies, and practices of teams they've experienced in the wild that were good at making software.

They write a book about it, design training courses, and offer up their services as a consultant to organizations that want to "do" this methodology so their teams can be good like the teams that inspired the methodology.

In a paradoxical way, methodologies are useless for the teams that actually need them. Before people were buying books about Scrum, there were effective teams keeping track of the work they needed to do, maybe as a list scribbled on a whiteboard in the office, an Excel spreadsheet, a series of index cards tacked to a bulletin board. They didn't need to be told about "Product Backlogs". They were releasing updates to their software on some quasi-regular cadence without knowing anything about "Sprints".

Scrum, XP, Kanban—you name it—cannot help your team with these problems:

  • We don't have the budget to hire good software developers
  • The manager of this team is a jerk and people don't want to work for them
  • The product owner is spread too thin so nobody knows what we're supposed to build
There may be some value is "adopting" a methodology if nothing else so that a group of people have a shared terminology in which to communicate, but I'm not sure beyond that. No methodology will make a team "good."

Never forget that a methodology is a description of one type of high functioning team—it's not a playbook for making a poorly functioning team into a high functioning team, and set your expectations accordingly.

Incomplete, with high quality

In a presentation I gave at a past job, I summarized the Agile philosophy as: "Deliver business value to real users faster."

Maybe because I came up as a developer around the time of the Agile Manifesto, I feel like I have Agile in my bones. I've never known any other way of looking at the process of creating software.

Get valuable, well-tested things to real users as fast as possible.

If you work for a company that makes hiking boots, then it's a big problem if you ship a product that has no soles attached. Hiking boots without soles are useless.

But hiking boots of the wrong color are useful. We can change the color of future iterations of the product if people like the hiking boots, but don't like the color.

Hiking boots of the wrong color are better than no hiking boots for someone who wants to hike, while hiking boots without soles are useful to no one.

When it comes to software, poor quality and incompleteness are not the same thing. All the hypothetical features we believe our users would want do not need to be present for them to get any value out of our work. The thing that we put out into the world does not need to be perfect, in fact, it would be weird if it was perfect.

I guess I'll be explaining this concept until the end of my career, but in software we must be okay with delivering the wrong thing quickly. Let's strive for making something incomplete, but with high quality.

Career Philosophy: Product vs. Infrastructure

A running theme of my blog over the years has been me trying to figure out the landscape of the software industry and where I fit within it.

I'm an "Evergreen" and not a "Stack Chaser". Cool. I don't enjoy CS and math enough to get hired at a FAANG company. Got it.

One dimension of the software career landscape that I had not considered until recently is Product vs. Infrastructure.

As Michelle Lim breaks it down in her post Stop Just Using Frontend or Backend to Describe the Engineering You Like, there are two broad categories of software engineers:

1. “Product-first” engineers are obsessed with using code to solve a user problem and they see code as just a means to an end.

2. “Code-first” engineers are obsessed with the abstractions, architecture, tools and libraries in the code. Elegant code is the end. 

Product-first engineers map to “Product engineering”—building, launching and maintaining features that solve user problems. They often love being in the same room as designers and product managers to learn about users, and they love finding technical opportunities that can improve the product.

Code-first engineers map to “Infrastructure engineering”—building infrastructure platforms that support applications, be it via building CI/CD pipelines, implementing logging, or supporting high traffic etc. They’re motivated to better the craft of programming and are often obsessed with things like test coverage, using the latest technologies, code architecture, etc.

We're so used to splitting engineers into "frontend" and "backend" roles. I love the idea Michelle puts forth that some engineers just want to be closer to the user's problem. That doesn't necessarily mean they have some preference for the set of technologies that run in a browser vs. run on a server, for example.  There are many ways to affect the user throughout the stack, and the technologies are not particularly relevant.

There's nothing more fascinating to me in the software world than learning about how users do their work and how I can use my engineering skills to make that work easier. And I feel very drained when I'm working "far from the user".

I guess I'm a Product Engineer. Who knew?

Include the Thing

I suppose you could file this post in my series of remote work posts, but it's really just about effective written communication in a team setting.

Here are some tips that I would summarize simply as: Include the Thing!


The humble hyperlink. Oh, how you simplify communication. Almost everything we do now is link-able.

  • You're writing a backlog item description that mentions work previously done. Include a link to the canonical backlog item that describes the previous work!
  • Someone has asked you a question in chat that you remember being answered by an article on the team's internal wiki. Hunt down the wiki article, chat them an answer that summarizes the relevant section of the article, and include a link to the article if they want a fuller answer! 
  • The build is broken. Crap! When you ask your teammates about this, include a link to the build log in GitLab that shows the error message.


A picture truly is worth a thousand words. There is almost always a good reason to include a screenshot. Reach for the PrtScn key as often as you reach for your glass of water.

  • Hey, I'm getting a JavaScript error when I click on that button. Include a screenshot of your browser that includes the button in question with your Chrome console open and showing the exact error you're talking about! Bonus points if you draw a circle around the button and the error text in the console. Bonus points if you capture in your screenshot the address bar showing the complete URL of the page in question.
  • Hey, I was looking at the config file and I'm wondering if that connection string is wrong? Include a screenshot of the config open in Visual Studio with a circle drawn around the line in question. Bonus points if you include several lines above and below so that the location within the file is obvious. Bonus points if you have line numbers turned on in your editor and you've captured the line numbers within the screenshot. Bonus points if you've captured the tab within the screenshot that shows the complete file path to the config file, or at least the file name.
  • Hey, I'm creating a JIRA ticket and I couldn't figure out which Project to pick. Include a screenshot of the complete new ticket form in JIRA where you've already filled out all the fields that you already know. Bonus points if you drop down the Project drop-down before taking the screenshot so the complete list of Project options is visible.


Including a relevant portion of a previous communication in your current communication provides focus and context.

  • You're emailing a co-worker on a different team that you don't talk to that often about a problem they helped you with several months ago. Instead of composing a new email from scratch, dig up the email thread from when they helped you previously and email them this time as a reply to the previous thread so that the context of your previous conversation is appended to the email!
  • You're writing an article for your team wiki and there's a relevant article on MDN you want to link to. Copy and paste the relevant section of the MDN article as a blockquote within your Markdown!
  • You're replying to a question a teammate asked a few hours ago in your team chat, but there have been many unrelated messages in the chat since then. Use the feature your chat app has for establishing a context for your reply! Some apps have a quote feature that includes the other person's message on top of yours. Some like Slack allow you to reply as a thread to the original message.


Whether you're using links, screenshots, quotes or something else, the goal is to:

Anticipate questions

What's the next thing the person I'm communicating with is going to want to know after they read what I've written? Can I just include that information now?

Ruthlessly eliminate ambiguity

What information could I include now that could point more directly at the subject? How can I be more specific? What is potentially vague about what I'm communicating?

Reset the context

How can I depend less on this person's memory to understand what I'm communicating? Is there a chance they've forgotten our previous communication? How can I establish a context for this communication?

Include the Thing!

Showing Up for Remote Work

Remote work is awesome. I've been doing it full time for over 5 years now, and I've learned the importance of "showing up" as a remote worker.

It's really easy to feel disconnected from people when you aren't in the same physical space. I've picked up a few habits that have helped me stay visible as a remote engineer.

Show Your Face

People are instantly humanized again when you see their faces. I've found myself assuming things about someone's personality and attitude when I've only communicated with them via text.

Who would you rather leave a comment on your pull request?


By default the various services that you use at work to collaborate with people are going to give you a lifeless avatar. Do the bare minimum and upload a picture of yourself to your profile on each one.

The same goes for Zoom meetings. Every laptop these days comes with a webcam, or you can buy a cheap USB version and clip it to the top of your monitor. Even if your hair is messy and your home office is drab looking, just turn on your webcam. Don't be this guy:

Speak Up

Simply hearing someone's voice is a powerful thing when you're not in the same physical space. It doesn't take much to just say "Good morning." at the beginning of a Zoom call or "Thanks, see ya." at the end of a call. 

When I'm attending meetings remotely, I try to speak more than I probably would if everyone were in the same room. Even if I don't have anything particularly original or earth-shattering to contribute, it doesn't hurt to say "Yeah, that makes sense" or "I agree". Your silent nods aren't going to be noticed in a Zoom call with ten people.

Show Your Work

I try to take advantage of the various activity feeds that surround my work as a software engineer.

For example:

  • Instead of coding for days on a backlog item and then making one big commit-push to the team's Git repository, break your work into smaller logical chunks that you can push daily
  • If you did some research as part of a backlog item that won't be captured as code in the repository, write up an article in the team wiki summarizing your findings and link to it from the backlog item or post a link in the team chat
  • Instead of the briefest possible comment in the morning standup like "Still working on item #4567", give a few sentences description of the specific progress you made on that item
  • Tag specific people in the comments on backlog items, pull requests, etc. when you've done some work that would be of interest to them

Acknowledge Communications

It's easy to feel like you're writing into a black hole when working remote. Let people know you're paying attention.

When someone writes a message in the team chat that helped you, throw a thumbs-up on it or tag them in a reply to say thanks. Same goes for nice or constructive comments on wiki articles you wrote or pull requests you submitted.

With Great Power Comes Great Responsibility

Remote work arrangements are a great benefit for engineers, and they require a great deal of trust between employer and employee to work. Since I'm not showing up in person, I make a conscious effort to show up in other ways.