Get professional value out of the next Twitter-like thing

The Bird hit another inflection point on Friday. Now, many people, myself included, are looking at alternatives or actively decamping1. It was quite a thing to experience.

Several days before, I read a post about the value one can potentially get out of Twitter. On one hand, it may not age well2. Network-effects will cause Twitter to lose “value” faster than it loses daily/weekly/monthly active users. On the other hand, thinking about how I might get tremendous value out of the next network is a useful thought experiment.

Herein, allow me to riff on how to get a surprising amount of professional value out of publishing to and participating in Twitter-like3 social networks.

The value proposition is two-fold:

  • the ability to publish into other folks’ attention streams (i.e., reputation building)
  • a high-quality stream of information to adjust my own world view/model

On the publishing/write side: note that folks like Patrick, Simon, and Laura are Very Good at Twitter. They’ve been writing there for years, building a reputation. In particular, they form thoughts such that they travel and evolve well on Twitter in particular.

With a lot of practice, I could reach this level of operation. Building the reputation, of course, is about showing up consistently for months and years. A few months of rebuilding my Twitter routine and ‘practice’ and I’m out networking with the best.

In other words, use Twitter as a big professional networking tool4. Instead, the networking happens at the idea level. Contribute and participate in developing ideas and the network comes to you.


On the read side: I’m guessing anyone who enjoyed Twitter in 2022 and gets useful signal out of it is equipped with:

  1. a well-curated list of mute-words5
  2. bespoke user lists which focus the valuable discussion and reduce the din of a global social/information network

Throughout its history, Twitter was often adversarial. There’s a “main character” of the day. Many folks come solely to build them up or tear them down. Disagreeing parties come to dunk on each other. Occasionally, they directly engage, but social bubbles/fortifications are the norm.

Anyone who gets professional value out of Twitter ignores that aspect. 🤷🏻‍♂️ In particular, they are using Twitter itself (or well-considered 3rd party applications) to automate filtering out the noise6.

I’ve dabbled in setting up mute-words and curated, high-signal lists. It worked pretty well at various points in Twitter’s history, particularly in combination. Perversely, now that we’re possibly in the waning days of Twitter’s influence, I’ve got a pretty good setup for finding interesting, new-to-me ideas. Sometimes those ideas put my work, or even the world, in a better perspective. That’s valuable!


Bottom line: you get out of Twitter-like networks what you put into it. The better I write, work the network, choose your sources, and manage the flood of information, the more likely interesting/valuable things will come my way.

  1. I feel like this happened at least twice before, probably circa 2015 and 2018?
  2. This started off as a thread that ended with this caveat: “Assuming that Twitter doesn’t drastically regress under New Management.” Reader, it did indeed regress.
  3. Tumblr, Mastodon, Micro.blog, Cohost, Fediverse, etc.
  4. Not in the way LinkedIn aims to do that around the resume.
  5. I started with this list, which is unfortunately paywalled now
  6. Mastodon in particular has community conventions around content warnings and requiring consent to see upsetting images or even posts about ongoing dramas. By social convention rather than software or regulation, this makes it a much better place for human brains to hang out.

Updating Eisenhower on planning

Previously: a long time ago, Dwight Eisenhower probably said something to the effect of: “Plans are useless, but planning is essential”.

Today, software development (and knowledge work writ large) are largely about speed in the service of more. Iterate faster, ask more questions, get more feedback, deliver more often. Success is less likely about having a good or well-formed idea from the outset, and more about how the idea evolves in the hands of people/customers.1

Let’s update Eisenhower’s insight on planning to harmonize with speed and quantity of iteration:

Static plans are useless, but dynamic plans, developed and iterated as information arrives, are the essence of leadership.

You have to plan. Stopping to think a multi-week project through isn’t Waterfall or a slow, bureaucratic process. It’s how you get your head into a project.

Lacking a plan isn’t an option2. If you choose not to have a plan, you’ll likely end up part of someone else’s plan. Their plan may not have the same outcomes or parameters in mind as you do. Better to have a plan.

Planning with your team is how you get everyone aligned and pulling in the same direction. The worst cases for a plan, that it’s tragically incomplete or wholly invalid, have a silver lining wherein the team that plans together pulls together. In the best case, you’ve front-loaded a bunch of coordination and collaboration, allowing teammates can work autonomously and efficiently.

The initial plan you or your team come up with is very much a rough draft. Surely risks will make themselves known and areas of unknown complexity/scope will present themselves. Don’t worry about rigorously adhering to the plan once you’re a few weeks into the project. Iterate and add to the plan until you’ve done all the useful work, and it’s time to start planning the next project.

  1. There is something to say about slowing down, seeking quality at every turn, and delivering a great, monolithic thing. Usually that involves some combination of internal iteration, auteur mindset, a strong creative scene, or harnessing lightning in a bottle. Everyone wants to fall in this category but counting on that is an unhedged risk.
  2. With apologies to Rush: “If you choose not to decide, you still have made a choice”.

Top of Mind No. 1

Delegating: supporting teammates, delivering the right context, setting good outcomes/goals.

Not delegating: managing/mitigating risk, resolving unknowns. “Delegate downhill work, tackle uphill work.”

🤔 Compilers are at once magic and the closest thing to mechanical tools in a software developer’s experience.

✍🏻 Reflecting on using Shape Up for the past few years…

Programming excellence: a small matter of practice

The key is deliberative practice: not just doing it again and again, but challenging yourself with a task that is just beyond your current ability, trying it, analyzing your performance while and after doing it, and correcting any mistakes. Then repeat. And repeat again. There appear to be no real shortcuts: even Mozart, who was a musical prodigy at age 4, took 13 more years before he began to produce world-class music.

Peter Norvig, Teach Yourself Programming in Ten Years

Norvig’s recipe, paraphrased:

  • get interested and program because it’s fun and continues to be fun
  • learn by doing
  • talk with other programmers, read other programs (“This is more important than any book or training course”)
  • work with other programmers and after other programmers
  • learn several languages with diverse capabilities and philosophies
  • learn the “computer” in “computer science”

And here I am, twenty-five years in, wishing I’d practiced more 🤷🏻‍♂️😆

Write more, coder inspiration, queryable coding environments

Simon Willison on writing about one’s work:

A tip for writing more: expand your definition of completing a project (any project, no matter how small) to include writing a blog post (or README or similar) that explains that project

Without this you’re skipping a relatively small step that unlocks a huge chunk of the value in the work that you have just completed!

This advice goes for internal company work too

I set up an internal blog at a previous employer using Confluence (because it was already available and has a good-enough blogging feature), but even something as simple as a dedicated Slack channel can work well for this purpose

And, writing more by lowering standards 😮

And as always: one big secret to writing more is to lower your standards

Published but “could have been better” is massively more valuable than something that eternally sits in your drafts

One of the biggest productivity improvements I ever made to my blogging was when I gave up on my desire to finish everything with a sparkling conclusion that ties together the whole post

Now I embrace abruptly ending when I’ve run out of things to say instead

Spoiler: I’m following this advice right now! 📈

Thorsten Ball collects greatest hits by Steve Yegge (who coincidentally just joined Sourcegraph):

And, on books/screencasts/blogs that have influenced him most as a programmer. A few that have influenced me too:

  • Destroy All Software
  • PeepCode Play by Play
  • Pragmatic Progammer
  • Practical Object-Oriented Design in Ruby
  • Agile Web Dev with Rails
  • Rands in Repose
  • Code Complete
  • 37signals’ books

Codebase as Database: Turning the IDE Inside Out with Datalog:

I’ve been wondering: what if this codebase model was as queryable as a database is? What new questions would we ask of our codebases, and what new ways would we find to visualize them? Furthermore, what if the language semantics themselves — types, completions, errors, etc — were specified as queries, which were also introspectable?

I believe that the design of languages and programming environments should not just be the province of a small priesthood of elite developers. Everyone should be able to look under the hood of their IDE, and be free to push its boundaries: embed it in a different context, create a domain-specific language with rich editor support, fork an existing language to play with its semantics, etc.

The opacity of the IDE’s inner model — and the rules by which that inner model is updated — are barriers to this being a reality. For IDEs to be introspectable and hackable, we must first expose this model and these rules: we must turn the IDE inside out.

Sign me up for queryable, malleable IDEs. I like RubyMine and JetBrains’ development products a lot. But, I often pine for the speed and low-ceremony extensibility of Sublime Text (or TextMate, back in the day). So let’s through “as easily queried as a database” on the pile while we’re at it. 😆

See also: Sourcegraph, language servers. (Someone in the back is yelling Lisp, the “Freebird!” of software development.) Furthermore, I wish Jetbrains’ MPS was less Java-centric and more tractable.

Onboarding when you don’t have access to the team

Mitchell Hashimoto, Contributing to Complex Projects:

The first step to understanding the internals of any project is to become a user of the project. You do not have to become an expert user, but my personal graduation criteria for this step is to try to build something real using the project, even if it is small or simple.

Analog: here’s a functional area. Set it up for yourself or on your localhost. Now, make a small, well-contained change.

Learn how to build the project and get a working binary (or equivalent). Don’t bother with understanding the build system, the dependencies, etc. Just cargo cult guides, websites, whatever you need to reliably and repeatedly go from source code to runnable binary on your system.

Analog: get to the point you can run the app, run (focused) tests, and see changes in the app. Then start trying to make functional changes.

To learn the internals, I like to use an approach I call “trace down, learn up.”

Analog: for your first several changes, read from the top of the call stack down as far as you can. Don’t try to make changes, but do try to note all the landmarks (files) you visit and how they relate to each other. Note “side quests” to investigate later as you go.

Don’t be afraid of complexity. I think too many engineers look at stereotypically complex projects such as programming languages, browsers, databases, etc. as magic or as destined for higher-beings. I like to remember that all projects were started by other humans. If they could do it, I can do it too. And so can you.

You, too, can gain enough understanding of an eight-year-old system to work on it as though you were around when some of it was written. In fact, your effort will compound: the longer you’re around, the more you will find curious code that, it turns out, you added in the first place. 😆

Perspective, you want it

Perspective is the lens we view our world, work, relationships, etc. All the luck, resources, or knowledge in the world are wasted without good perspective. If we’re talking about life like it’s a role playing game character sheet, you want to have a good perspective stat/multiplier.

Some clever tricks:

  • keep the mind open and flexible to other perspectives; seek them out
  • practice at holding many perspectives simultaneously
  • know the limitations and strengths of a perspective as you navigate the world
  • know when your default perspective makes a scenario more difficult and how to fall back to a perspective you still believe in
  • get out of routines periodically and see if it changes how you see things
  • more so, get out of your bubble; see people of a different background live their lives, reflect on what factors brought them there and how factors are different/similar for your life
  • even more so, travel outside your city/state/country; axiomatically the people most different from you live in a place far away

It’s often tough to gain perspective. Most of the defaults in life steer us away from insight. School, cliques, work, even typical travel nudge us toward seeing familiar things with similar people who live similar lives. I’m by no means an expert at breaking out of these ruts. I’m pretty enamored with my routines. Unfortunately, I don’t have a clever trick to offer here.


Julian Shapiro, What you should be working on:

What is admirable is periodically killing your momentum to ask, Should I still be doing this?

Michael Lopp, The Art of Leadership: Small Things, Done Well:

Let others change your mind. There are more of them than you. The size of your team’s network is collectively larger than yours, so it stands to reason they have more information. Listen to that information and let others change your perspective and your decisions. Augment your obvious and non-obvious weaknesses by building a diverse team. It’s choosing the path of least resistance to build a team full of humans who agree with you. Ideas don’t get better with agreement. Ideas gather their strength with healthy discord, and that means finding and hiring humans who represent the widest possible spread of perspective and experience. Delegate more than is comfortable. The complete delegation of work to someone else on the team is a vote of confidence in their ability, which is one essential way that trust forms within a team. Letting go of doing the work is tricky, but the manager’s job isn’t doing quality work, it’s building a healthy team that does quality work at scale.

Be like Bill Gates and Warren Buffett: If you’re not spending 5 hours per week learning, you’re being irresponsible

Former president Obama perfectly explains why he was so committed to reading during his presidency in a recent New York Times interview (paywall): “At a time when events move so quickly and so much information is transmitted,” he said, reading gave him the ability to occasionally “slow down and get perspective” and “the ability to get in somebody else’s shoes.” These two things, he added, “have been invaluable to me. Whether they’ve made me a better president I can’t say. But what I can say is that they have allowed me to sort of maintain my balance during the course of eight years, because this is a place that comes at you hard and fast and doesn’t let up.”

Leadership keywords

My current theory of leading software teams and projects has four keywords:

  • Trust: I assume everyone is working to get the job done. They assume I will help them get the job done. This starts off more like faith and grows into trust as teams coalesce.
  • Autonomy: each person on the team is independently productive for a significant chunk of their day. When they make assumptions to stay unblocked, they are adept at collaborating asynchronously to verify them or correct course.
  • Agency: each person solves the task they’re working on in a way they see fit, within the conventions shared by the team. If an interesting idea comes up outside of the those norms, anyone can pursue it such that they maintain the trust/faith of their colleagues.
  • Support: each person knows that the team, particularly yours truly, is there to help each other. This most often manifests as pairing on troubleshooting, designing, coding, etc. Most importantly, sometimes it is sharing the load when one person is feeling overwhelmed.

Support is a recent addition. I had previously thought that autonomy and agency were the things enabled by trust. But I’m starting to think1 support is a crucial part of the equation too.

Without support, you’re just throwing people into the pool and telling them they can stay a-float however they like. It omits the “get good enough to swim” part, which is pretty crucial!

This kind of support is most obvious when you’re bringing someone new onto a team. But you need it throughout an individual’s tenure on your team. The people with years of deep experience and history in their head need support of a different variety.


Teaser: I’m on the fence about adding 2-3 more words to my repertoire. There’s a lot of moving parts to leadership!

  1. Largely due to onboarding people to a team/system/organization with a long history. This doesn’t happen without a larger-than-normal support effort. Perhaps that effort is amortizable over time (i.e. writing docs), but it’s still a big lift.

Managers can code on whatever keeps them off the critical path

Should engineering managers write code?:

Spending time in meetings and working through complex team relationship issues leaves you feeling more drained than energized most days. You look longingly at your team and feel a slight tinge of envy. You want to code again.

The good news is that you can! The bad news is that you shouldn’t. At least not directly on your team’s codebase and not on any critical path work.

Good ideas therein! Let me emphasize one I’m particularly fond of.

In my first engineering management role, I had the opportunity to go completely hands off. For a while, I found it a little off-putting. I really like solving problems with code! (I later realized leadership and management are solving problems with people, but that’s for another time.)

I felt a lot better about engineering management once I figured out it gave me license to code on impractical things. When you’re an EM (the hands-off variety, not the sitting-on-the-fence variety), you have the opportunity to code on whatever draws your interest, knowing it won’t block your team.

That’s a pretty rad opportunity for someone like me who’s a bit of an esoteric tinkerer.

If you’re less of a tinkerer and more of a shipper or solver, even the highest functioning teams have some pile of ambitions and ideas they aren’t actively pursuing. An engineering manager can explore the frontiers on these ideas. Maybe a plan is made, research is noted, or its found the idea isn’t all that great after all. Still a win!

As long as your code doesn’t create challenges or blockers for your organization: dive into it, have fun, explore the space!