Good post by Vadim Kravcenko on Things they didn’t teach you about Software Engineering:

Although it may sound surprising, the primary focus of a software engineer’s job is not writing code but rather creating value through the use of software that was written. […] Elegant code, best practices, smart solutions, design patterns — these are done for the sake of your fellow software engineers who will work on the codebase after you rather than helping you fulfill the purpose of bringing value.

And speaking of meetings:

It’s all interconnected, and the meetings are where the information is shared. As a software engineer, you are responsible for some part of this information sharing, so it would be irresponsible to hinder it. You might not like it, but the information must be shared for the system to remain efficient.

Via Chris Coyier I found this great post by Karl Sutt on How to communicate effectively as a developer. I especially appreciate him pointing out the importance of communicating clearly in short-form writing like Slack messages. His example of “low-resolution” vs. “high-resolution” writing in that context is a useful reminder for all of us:

In both cases, the example on the left is what I call “low-resolution writing”. There is very little context, too much reliance on pronouns and unclear references. The writing is not emphatic—the reader has to spend extra energy to work out what is being said. The examples on the right, on the other hand, try to make the reader do less work, even though it is more effort for the writer. The writer clearly has thought about how the message will be read.

This idea is similar to what Erin Meyer refers to as “high-context” vs. “low-context” communication in her (excellent) book The Culture Map: Breaking Through the Invisible Boundaries of Global Business. She explains in this HBR article:

I compare cultures along the Communicating scale by measuring the degree to which they are high- or low-context, a metric developed by the American anthropologist Edward Hall. In low-context cultures, good communication is precise, simple, explicit, and clear. Messages are understood at face value. Repetition is appreciated for purposes of clarification, as is putting messages in writing. In high-context cultures, communication is sophisticated, nuanced, and layered. Messages are often implied but not plainly stated. Less is put in writing, more is left open to interpretation, and understanding may depend on reading between the lines.

Choosing the right communication style for the right context is an important skill for everyone, but especially product (and other) leaders. If we assume too much context is known, people will misinterpret what we mean with our words.

Brad Frost argues that design tools are holding us back because “they require a specific toolchain in order to function”. Instead, what we need is closer collaboration:

Tooling can help, sure, but it’s not a silver bullet. To truly address the realities of the medium for which you’re designing, designers and developers should collaborate as equals to solve problems together. That means more talking and real-time collaboration and less time spent throwing static artifacts and Zeplin links at each other.

Ben Nadel proposes A Good Samaritan Law For Engineers At A Software As A Service (SaaS) Company:

How can we instill in our people the unwavering conviction that they have the freedom to create a better user experience?

One idea that popped into my head was to create a Good Samaritan Law For Engineers: an explicit promise by the company that no engineer will ever be fired for attempting to, in good faith, help a user or create a better user experience. And, I don’t mean as an implicit piece of the Tribal Knowledge; I mean as an explicit, codified part of the culture — an entry in the employee handbook — a poster, up on the wall, that any employee can look at and point to and use in their decision-making algorithm.

This should, of course, be true for everyone in an organization, not just engineers. But I like the point about codifying it — making it a principle that’s published, well-known, and ingrained in the company culture.

Megan Quinn’s post on Development Cadence starts off really strong:

The hallmark of a well-run development engine is a development cadence that is brisk in bringing new products to market without burning out its builders.

And then it only gets better from there. Her point about being “flexible on scope, fixed on time” is spot on:

One way to establish a good development cadence is to commit to a predictable launch schedule and avoid slipping by pushing out features, not time. Some organizations commit to launching every month with the notion of ticks (small feature releases/fixes) and tocks (bigger, marketable moments).

Will Larson shares some interesting perspectives on teams in the interview How to Size and Assess Teams From an Engineering Lead at Stripe, Uber, and Digg:

Larson believes that the fundamental challenge — and cornerstone — of organizational design is sizing teams. “The most powerful unit of work is a gelled team. People who know how to work together and are practiced at working together can accomplish truly remarkable things,” says Larson. “When managers design too literally around the current product or architecture, they churn people and lose what I think is the only truly renewable source of energy in the world: people who really love — and know how — to work together.”

He goes on to describe four states a team can be in — falling behind, treading water, repaying debt, and innovating — and the best way to improve teams that are in each of those stages.

Karolina Szczur makes some excellent points about using “technical debt” as an excuse for subpar products in The Technical Debt Myth:

Technical debt becomes a convenient blanket statement entailing frustrations, rushed decision-making, lack of process or architecture, and tedious maintenance tasks — the get-out-of-jail-free card for delivering a subpar experience.

It’s crucial to understand that as software and design grows older, that doesn’t necessarily mean we’re dealing with debt. We must look deeper under the surface to find the root cause of bottlenecks we’re facing. Only when we carefully assess the symptoms can we find solutions to building products that last.

While we’re on the topic, the most useful article I’ve read on technical debt is Henrik Kniberg’s Good and Bad Technical Debt (and how TDD helps) from way back in 2013. He discusses good debt, bad debt, and the importance of having a “debt ceiling”. Highly recommended post, and still very relevant.

Jeremy Keith writes about the developer community’s need to always talk about new things in Dev perception. I think the same can be said for every other profession, including product management:

It’s relatively easy to write and speak about new technologies. You’re excited about them, and there’s probably an eager audience who can learn from what you have to say.

It’s trickier to write something insightful about a tried and trusted (perhaps even boring) technology that’s been around for a while. You could maybe write little tips and tricks, but I bet your inner critic would tell you that nobody’s interested in hearing about that old tech. It’s boring.

The point he makes in his post is a very good one — that we should always evaluate any technology (or, in our case, methodology or framework) based on appropriateness, not newness. It reminds me of Kellan Elliott-McCrea’s excellent list of questions a team should answer before they decide to adopt a new technology in their software development process.

Phil Johnson has some good advice for product managers in The Goldilocks of Process:

Blindly following process is a project-killer—not just in terms of efficiency. The real poison is the mentality: in these cases process became a crutch to lean on, with these individuals no longer thinking critically about their tasks. In many ways, the process became the job, where process really should be what enables the job. This rings doubly true in the software development world.

On any team, you want your process like you want your porridge: just right. If you have too little, the team may not know what the priorities are, or who is responsible for the next step. Too much, and your team will end up doing more process than actual work. The right strategy should be flexible enough to fill in the cracks of the team’s blind spots while enhancing their strengths. It’s up to the PM to find that sweet spot.

This also reminds me of Michael Lopp’s essay The Process Myth, and these words that will forever be etched in my brain:

Engineers don’t hate process. They hate process that can’t defend itself.

Herb Caudill’s Lessons from 6 software rewrite stories is an extensive analysis of the rewrite projects of companies like Basecamp and Trello, why they succeeded or failed, and what we can learn from them:

Once you’ve learned enough that there’s a certain distance between the current version of your product and the best version of that product you can imagine, then the right approach is not to replace your software with a new version, but to build something new next to it — without throwing away what you have.

Eventually all product managers face a decision like this, so I found these case studies invaluable.