DEV Community: Ben Potter

A Hiring Manager’s Perspective on Tinkering & AI

Ben Potter — Wed, 08 Jul 2026 21:28:35 +0000

I'm a hiring manager on the product team at Coder, a growth-stage tech company founded in 2017. Everyone on the product team uses LLMs daily.

It's been fun to watch: docs folks fixing SEO issues on the website, engineers writing documentation, PMs building live prototypes, marketers shipping website changes directly. Nobody mandated any of this.

There are plenty of negatives too: layoffs, junior roles drying up, students worried about their careers, and a flood of low-quality generated content everywhere you look. I'm not going to solve those in this post. Instead, I'll share how AI actually affects hiring at one company that uses these tools heavily. If you're a candidate, I hope this helps you see how at least one company is thinking about it. I can assure you that we aren't alone.

Context on how we work

Every company values different things, so here's the environment my perspective comes from. If your values (or your company's) are different, your conclusions probably should be too.

We hire tinkerers. When I joined Coder, the first thing I did was stand up the product and poke at it. When I wrote my first blog post, I ended up also fixing the website's build process because it annoyed me. This attitude is company-wide. Nearly every department has built internal tools nobody asked for. We've also hired over 4 people directly from our user community, people who were already tinkering with the product before we ever paid them to. As we scale, we've had to get clearer about ownership, but I still want people who look outside their job description.

There's always more work than people. On the tactical side: improving our product's UX, writing a new feature or integration, improving documentation clarity, fixing a tiny bug. On the strategic side: better communication between departments, faster decisions.

We've seen a lot of hiring and firing. We're still a young company, but we've already been through plenty: we scaled too early once and paid for it with layoffs, and we've done hiring freezes while finding product/market fit. Right now we're hiring fast: 21 people in the last month, at a company of ~180. None of those layoffs or freezes had anything to do with AI. They came down to larger business reasons, the same boring ones that ended jobs long before LLMs existed.

What's actually changed

The number of open roles hasn't gone down. Expectations per role have gone up, but not in the way people assume. Myself and many of my peers are not concerned about squeezing more output out of everyone. It's about diversifying output in favor of impact: a docs person can contribute fixes directly, a PM can prototype their own ideas. This isn't about filling skill gaps. It's that going the extra mile got a lot cheaper, so we expect people to do it. We're less excited about "builders" in the raw sense, since building is cheaper than it's ever been. We're more excited about candidates who can demonstrate taste, understanding, and impact.

A good litmus test for me is whether someone is only using AI to generate new programs from scratch (likely to get scrapped/unmaintained), or to build on somebody else's ideas and understand a perspective or part of the company they haven't before. And then whether they actually get these shipped, improved, and retained. Getting 90% of the way there really doesn't matter

In practice:

We filter for taste. I want to understand if the candidate has a perspective, an experience, or even a distaste for something, and whether they feel comfortable expressing and applying it.
We still hire juniors (more than ever, actually). We just spun up a summer internship program, and we're hiring more junior roles than we ever have.
Communication skills are more important than ever. If someone sends you sloppy AI-generated work, or you disagree with an idea, you need to be willing to say so. And when you don't understand something, loop in a colleague to collaborate, without dumping work on them to review or shipping while hiding your gaps.

My environment is not for everyone

Coder values tinkerers, fast-paced ownership, and people going the extra mile. We expect a lot out of people, and those expectations aren't always documented in some playbook. Not everyone wants to work in an environment like that, and that's OK.

I'm also only in one specific department of Coder (product management and developer relations), and other teams and roles will be different. AI will certainly automate tasks that are central to some jobs. I'm not saying everyone will be fine, that all employees will become curious, or that those who prefer to get a task, execute, and repeat will (or should) succeed in a knowledge worker economy. I'm also not saying we have all the answers or that Coder is AGI-proof; I just don't think those conversations are useful when it comes to hiring or getting a job. What I am observing is a significant positive impact on how we work together and how we build better products, and I'm optimistic about the companies we can build with it.

If you're looking to get into another industry or work environment, I'd push you to research what that company values and how they write about AI (I'm sure they are). If you're a hiring manager, it can be helpful to write about your experiences like I did today. If nothing else, it'll help candidates figure out where they're a good fit and what types of work environments excite them as AI changes how we work.

If you're a candidate

More than any specific advice, I'd encourage you to think about how hiring managers are thinking (this blog post reflects how I think), rather than treating posts like this as a checklist.

That said, a few things transfer anywhere. Joining the community of a product you want to work on (ours or anyone's) is a great way to learn it and see what people are actually working on.

Form real opinions about the things you use and build, and get comfortable sharing those opinions, including when you disagree with someone or how you can make something better.

At this point, it isn't even about showing or hiding AI usage in an interview. I'd recommend spending more time thinking about how you can apply your unique skills to make the company better than showing off what you've built, unless what you've built has users and impact.

And if you're earlier in your career, don't count yourself out. As I mentioned, we're hiring more junior roles than ever, and I know we're not the only ones.

Achieving low latency remote development

Ben Potter — Mon, 14 Mar 2022 13:17:21 +0000

Remote IDEs bring speed and productivity benefits to software teams. Server-class machines lead to faster performance and reduced cycle time between changing code and seeing the result. For developers, this means faster onboarding and less time troubleshooting environments.

However, it’s important to make remote IDEs feel as fast, if not faster, than local machines. In this post, we’ll cover latency.

Latency hinders flow

As demonstrated by a typing latency simulator, delays immediately impact your productivity. Even with powerful servers, a reliable connection is just as important.

In this post, we’ll refer to “latency” as the connection delay between the developer (client) and workspace (server), and not operations inside the workplace itself (compiles, builds, tests) as those are unaffected by the user’s internet speed.

Let’s take a look at how we can tune remote workspaces to have the “snappy” experience we know and love.

Optimize your infrastructure

First, we recommend using servers close in proximity to your developers! 🌎

At Coder, we have a distributed engineering team. Our developers can pick between servers in the United States, United Kingdom, Spain, Australia for the optimal experience. If engineers join from another location, we can quickly deploy another workspace provider in that region to support them.

If you are using a managed development platform, this is not something you can control. If geolocation and network speeds are important to you, self-hosting with your workspaces is advised. You can use software such as Coder, Gitpod, or a homegrown solution.

Use remote IDEs, when possible

If you’re developing through a virtual desktop solution (e.g VDI, RDP, VNC), the overhead from streaming an entire desktop environment will often result in additional latency.

Whenever possible, we recommend using native IDEs (web-based or desktop). With VS Code and JetBrains remote development extensions, you can develop directly on remote workspaces with low latency.

If you still need to access desktop-only apps, you can still use your virtual desktop to complement your IDE, potentially all through the same workspace.

If you need fast remote desktop access, Parsec is an emerging tool to keep an eye on. At the time of writing, it only supports Windows and macOS hosts.

Use direct connections, whenever possible

Reducing proxies and network hops provides users a snappier and more reliable experience, which is why we went through the effort of implementing a peer-to-peer network architecture in Coder. As a result, we have achieved a 68% latency reduction, as measured by our workspace ping utility (61.23ms to 29.92ms) for our internal developer workspaces.

While your own performance improvement may vary depending on your network topology, in general, reducing the number of network hops and the physical distance between your computer and the server will reduce your perceptible latency.

Improving SSH responsiveness

For those who prefer to use vim/terminals development, mosh is a great tool for reducing perceived latency in SSH connections.

Mosh particularly comes in handy if you are on a limited internet connection, or if you’re far away from the data center.

What about offline mode?

You may find yourself in cases where you’d like to access your workspace without a stable internet connection, such as on an airplane.

We plan to cover this in a dedicated blog post, but our general recommendation is to define your remote workspaces with non-proprietary tools. With Dockerfiles, devcontainers, or standard VM images, you can optionally run your environments on local machines for an, albeit slower, offline development experience. Once an internet connection is restored, you can sync files back to your remote workspace.

Coder: self-hosted developer workspaces

If you’re serious about moving software development to your infrastructure, we’d love to chat. You can also install Coder for free and try it yourself.

Faster JetBrains IDEs with shared indexes

Ben Potter — Sun, 02 Jan 2022 21:53:11 +0000

If you develop with IntelliJ IDEA, PyCharm, GoLand, or other JetBrains IDEs, it’s likely you’ve waited for “indexing” to complete after opening a project. While this may be annoying, it’s necessary for IntelliJ and other heavy-weight IDEs to have features such as code search, highlighting, refactoring, and code completion.

Waiting for an IDE to finish indexing a project might not be a big problem for many workflows. After the first load, indexes are cached and subsequent runs are faster. However, indexing time can be a huge blocker for developers, especially in these cases:

large projects (monorepos, many dependencies, monolithic applications)
running old/slow machines (indexing is CPU-intensive)
ephemeral developer workspaces (containers, remote IDEs)

In this post, we’ll cover how shared indexes can significantly reduce IDE load times, share some examples, and a one-line command to generate these for your project. (Historically, shared indexes have been difficult to set up)

First, how indexing works

Indexing works by traversing the project’s codebase to create a “virtual map” of classes, methods, and objects for future lookups. After the index is generated, it is cached on your device for later use.

Indexing a codebase will likely take the longest the first time you open it on your machine. When the codebase changes, such as pulling code or switching branches, your indexes will “update,” but significantly faster than the first time.

Shared indexes ⚡

Shared indexes make it possible to host pre-generated indexes for others to download, significantly improving loading speeds across your team. These remote indexes work in conjunction with local indexing to ensure your IDE always has up-to-date information on the codebase.

GIF: Loading the code-server project in WebStorm

Generating shared indexes for your project

JetBrains has a guide for creating shared indexes, but it involves many steps, including downloading custom tooling and uploading indexes to a CDN. It also lacks instructions for automating this process, to generate indexes in CI, for example.

Using a Docker container to generate shared indexes makes it simple to try locally or automate with cron/CI:

cd your_large_codebase/

# generate shared indexes
docker run -it --rm \
  -v "$(pwd)":/var/project \
  -v "$HOME"/indexes-output:/shared-index \
  -e INDEXES_CDN_URL=https://cdn.myserver.com/project \
    -u "$(id -u):$(id -g)" \
  bencdr/indexer:idea-2021.3

After generating indexes, you can upload the output folder to your CDN, or a local server. You can also use shared indexes without a CDN by using a network share or even your local filesystem for testing. Check out my GitHub repo for details:

bpmct / jetbrains-indexer

Generate & package JetBrains shared indexes with a Docker container.

Benchmarking shared indexes

I tested indexing time for some popular projects on my 2019 MacBook Pro. To benchmark your own projects, File → Invalidate Caches in your IDE will allow you to opt in/out of downloading shared indexes to simulate first launching your project.

Project	Language(s)	Local indexing 🐌	With shared indexes ⚡	Improvement %
kubernetes/kubernetes	Go	2m 40s	22s	727%
cdr/code-server	Typescript	2m 30s	34s	441%
Coder internal monorepo	Go & Typescript	3m 20s	32s	625%
jetbrains/intellij-community	Java	6m 30s	2m 15s	288%

These times were averaged across two test runs. Your mileage will vary depending on network speeds, device performance, etc.

Remote development & shared indexes

Recently, JetBrains released remote development support, making it simple to develop from powerful, remote workspaces. On-demand workspaces have a lot of benefits, such as faster onboarding and better reproducibility. However, first-time indexing happens much more frequently, since, after all, workspaces are meant to be ephemeral.

Shared indexes work with Coder, our remote development platform. Coder supports all JetBrains IDEs locally, or via the web browser. If you don’t want to host a CDN for shared indexes, you can include them in the workspace image, so everything loads in a snap ⚡

If you’d like to learn more about Coder, you can request a demo or try it for free.