In this issue, you'll use a tool that manages your programming language version, tasks, and environment variables at the same time. But first, you'll examine how your day-to-day behaviors can impact how people perceive you. You'll also see that not every reference is a formal one.

Your Career Has a Permanent Record

This might seem obvious, but many people act as if their actions exist in isolation, forgetting that careers span decades and industries are smaller than they appear. You build your professional reputation every day through every action you take. How you show up at work, interact with others, meet deadlines, and support your team creates lasting impressions.

When you ask someone for a professional reference, you're asking that person to put their reputation on the line for you. They're vouching for your abilities and character. If you excel, their judgment looks sound. If you underperform, it damages their credibility. This makes people cautious about who they recommend.

And it's not just how your bosses and leadership perceive you. Your peers watch how you work, and their opinions matter tremendously. Today's teammate might become tomorrow's hiring manager, team lead, or executive with influence over a role you're after.

Good references don't just happen. They come from consistent performance, reliability, and positive interactions over time.

Reputation-damaging behaviors to avoid

Here are a few common ways you could damage your reputation, especially if they become a pattern of behavior.

• Missing deadlines without communication. Even if you eventually deliver, repeatedly submitting work late creates a perception of unreliability. Your team stops counting on you for time-sensitive projects.
• Taking credit for team efforts. Claiming ownership of collaborative work or failing to acknowledge contributions from others gets noticed quickly. Word spreads about this behavior, and teammates become reluctant to collaborate with you.
• Overcommitting and underdelivering. Saying yes to everything but completing little damages trust more than setting realistic expectations from the start.
• Being the "wet blanket". Regularly criticizing ideas without offering solutions marks you as negative rather than constructive. This reputation sticks even when you change teams.
• Undermining decisions after they're made. There's a difference between thoughtfully challenging ideas during discussion and continuing to criticize decisions after they're finalized. Once a direction is set, your public opposition damages your reputation more than improves outcomes.

Another thing that can hurt you is quitting without notice. It might feel satisfying to "table flip" and walk out when you're frustrated. After all, you don't owe a notice to your employer in many cases; it's a courtesy. But recognize that your team gets left holding the bag. They'll remember the extra work and stress you caused them for years. If you're fired, colleagues often take your side. But when you abruptly abandon them, that breach of trust follows you.

You might think, "Oh, I'll never work with these people again, anyway, so I can hit the reset button on my next job." Think again.

Backchannel references are real

Your formal references only tell part of the story. Hiring managers regularly reach out through their networks to learn more about candidates. Someone considering you for a role might contact a mutual connection at your previous company or within your industry to get an unfiltered perspective.

These informal conversations happen more often than you think. With professional networks like LinkedIn making connections visible, finding someone who knows you takes minutes. A casual "What was it like working with them?" can reveal more than any formal interview, especially if the person they speak to is trustworthy.

Repairing your reputation takes time

You can repair a damaged professional reputation with consistent effort and time. One strong performance won't erase a pattern of missed deadlines or difficult interactions. You need to demonstrate changed behavior repeatedly before perceptions shift.

Start by acknowledging past shortcomings without making excuses. Then focus on rebuilding trust through reliable work and positive communication.

• Create visibility for your work by sharing updates and celebrating team wins.
• Support colleagues generously and acknowledge their contributions.
• Keep commitments and communicate early when challenges arise.
• Listen more than you speak in meetings.
• Embrace constructive feedback and show improvement.

How you communicate, collaborate, and handle challenges matters just as much as your technical ability. Five years from now, when you apply somewhere new, your former teammate might be sitting in the interview panel or be asked about working with you. How you treated them, supported their work, and showed up as a team member will influence what they say.

Things to Explore

• Kew is a music player for your Terminal. You can search for music files, create playlists, and more.
• IPLocate is an IP geolocation API that provides information about security threats.
• Kestra is "an open-source, infinitely-scalable orchestration platform that enables all engineers to manage business-critical workflows declaratively in code." Since I've spent a few years with Temporal, I'm looking at this with interest. I also like their documentation.

Manage Project Dependencies with Mise

Mise gives you a single tool to manage your development environment, from the programming language you use and environment variables you set, to the tasks you run. Think of it like combining make, direnv, and a version manager like nvm or rvm. Rather than juggling multiple configuration files and tools, you use one tool with a configuration file for everything.

To demonstrate, you'll use Mise to manage the dependencies and environment for a small Node.js project that talks to OpenAI and feeds it a page to summarize and create an SEO description.

To follow along, you will need an OpenAI API key and some credits added to your account.

To install Mise on macOS, use Homebrew:

$ brew install mise

On Windows using Winget, install with:

> winget install jdx.mise

Or use Chocolatey:

> choco install mise

For Linux machines, see the official Getting Started page to find instructions for your platform.

With Mike installed, create a directory to hold your SEO summarization project, and switch to that directory:

$ mkdir seo-summary-cli && cd seo-summary-cli

Now tell Mise to use Node.js version 20 for this project:

$ mise use node@20

Mise downloads and installs Node.js 20:

gpg: Signature made Tue Apr 22 05:30:48 2025 CDT
gpg:                using RSA key A6023530FC53461FEC91F99C04CD3F2FDE079578
gpg: Good signature from "ulises Gascon <ulisesgascongonzalez@gmail.com>" [unknown]
mise node@20.19.1 ✓ installed                                                                                                                                                                                         mise ~seo-

Confirm Node.js 20 is available by using the mise exec command:

$ mise exec -- node -v

Using mise exec runs commands under the Mist environment.

Create a package.json file for your project:

$ mise exec -- npm init -y

Now Install the necessary dependencies using npm. You'll use the OpenAI package to talk to OpenAI's API and the Cheerio package to parse HTML:

$ mise exec -- npm install cheerio openai

Next, add your OpenAPI key to the environment by saving it to a .env like you would if you used dotenv or another environment tool:

$ echo 'OPENAI_API_KEY=your-api-key-here' > .env

Now open mise.toml and add this section to load that file:

[env]
_.file = '.env'

Now you don't need another third-party tool or Node.js package to manage the environment variable. Make sure you ignore the .env file you created so you don't check your key into GitHub.

Check your environment to ensure the key exists:

$ mise env

Create the seo-summary.js file that grabs the page and sends it to OpenAI for summarization:

#!/usr/bin/env node
const cheerio = require('cheerio');
const { OpenAI } = require('openai');

const url = process.argv[2];
if (!url) {
  console.error('Usage: node seo-summary.js <url>');
  process.exit(1);
}

(async () => {
  try {
    // Fetch page content
    const response = await fetch(url);
    const html = await response.text();

    // Parse and extract text
    const $ = cheerio.load(html);
    let text = '';
    $('body *').each((_, el) => {
      const nodeText = $(el).text().trim();
      if (nodeText) text += nodeText + '\n';
    });

    // Send to OpenAI
    const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
    const result = await openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        { role: 'system', content: 'You are an expert SEO assistant.' },
        { role: 'user', content: `Summarize the following page in 160 characters or less:\n\n${text}` }
      ],
      temperature: 0.7,
    });

    console.log('\nSEO Summary:');
    console.log(result.choices[0].message.content.trim());
  } catch (err) {
    console.error('Error:', err.message);
    process.exit(1);
  }
})();

Open mise.toml and create a new task to run the file with Node.js:

[tasks]
summarize = "node seo-summary.js"

Finally, run your program using your Mise task, passing the URL you want to summarize:

$ mise summarize https://example.com

This loads up the version of Node.js, loads the environment variable, and runs the task. The URL for the site gets passed as an argument to the task, which is sent as the argument to the Node.js script. The result is a summary of the page.

Now that you've used Mise for this project, you may want to set it up with your shell so that it automatically activates the environment and tool versions when you switch to your project directory. This way you can run your commands directly instead of using mise exec when you run commands . See the documentation for instructions on how to do that with your shell of choice.

Mise gives you consistent tool, task, and environment management for your projects, regardless of programming language.

Parting Thoughts

Here are a couple of things for you to think about before next month's issue:

• Have you experienced a situation where you've been uncomfortable giving a reference to someone because of how they interacted with you?
• Think of three people who would say glowing things about you if they were contacted tomorrow without your knowledge. What would they say?

As always, thanks for reading.

I'd love to talk with you about this newsletter on Mastodon, Twitter, or LinkedIn. Let's connect!

Please support this newsletter and my work by encouraging others to subscribe or by buying a friend a copy of Exercises for Programmers, Small, Sharp Software Tools, or any of my other books.