Coding still matters. But it’s no longer what separates skilled developers.

Most developers were trained for a world where writing code was the hard part. 

That world is gone. 

Today, syntax is cheap and context is expensive. 

Knowing how to code still matters. But top performers know how to orchestrate work across repositories, tools, teammates, and AI agents.

In practice, that means knowing how to:

• delegate chunks of work to tools and agents 

• keep context intact as work moves across systems 

• design workflows that reduce friction instead of creating it 

Orchestration is quickly becoming a career differentiator. And one that almost none of us was taught in school. 

A lot of this shows up in the terminal, where many of the “not-quite-coding” parts of the job already live. Tools like Copilot CLI and GitHub CLI turn the terminal into a control surface for delegation. 

Wherever you are in your career, here’s how to start building it. 👇 

Skill #1: Learn how to delegate reasoning 

A lot of development time gets burned on small, recurring chores: rerunning flaky CI, digging through logs, and fixing the same class of failure repeatedly. 

You can muscle through that work, but in this new era, you’re better set to succeed if you delegate the investigation first. 

What this looks like in practice: Instead of manually parsing logs, ask an agent in your terminal to investigate the failure and explain what happened. 

With Copilot CLI, type: 

 gh copilot explain the latest failed CI run         

 This turns a manual debugging loop into an AI-assisted diagnosis, so you can focus on deciding what to do next. 

 The bottom line: Delegating reasoning frees you to spend your energy where it matters most. 

Skill #2: Turn repeated fixes into workflows 

You’ve probably fixed the same kind of issue more than once. The second time is faster. The third time it’s annoying. By the fourth time, you’re muttering to yourself, “This should be a workflow.” 

That instinct is orchestration. 

What this looks like in practice: Instead of relying on memory or scattered notes, capture the steps as something you can rerun whenever the issue shows up again. 

Install the GitHub CLI workflow extension that enables these commands: 

gh extension install github/gh-aw   
gh aw add githubnext/agentics/ci-doctor   
gh aw compile   
gh aw run ci-doctor          

 This turns a one-off fix into a repeatable workflow your whole team can reuse. 

The bottom line: If you’re fixing it twice, it should be a workflow. 

 Skill #3: Operate and improve your systems 

Setting up a workflow feels productive. Running it over time exposes whether it actually works. 

Workflows drift, repositories evolve, and edge cases appear. Things that worked a few months ago can start to break. 

What this looks like in practice: Instead of assuming your automation is fine, check how it’s performing, spot patterns in failures, and tighten it over time. 

If you installed the GitHub CLI workflow extension in Skill #2, you can check the health of your workflows with: 

gh aw status   
gh aw logs ci-doctor   
gh aw health ci-doctor           

These commands show you what’s running, what’s failing, and whether your workflows are staying healthy. 

The bottom line: Building systems is good. Running them is the job. 

Moving forward together 

Development looks different than it did even a couple years ago. The leverage now comes from how you move work through systems. 

You don’t have to reinvent your workflow overnight. Start with one task you’ve fixed twice and turn it into a workflow you can rerun. 

Add an automated Daily Repo Status workflow in 10 minutes 👉 

✨ This newsletter was written and produced by Gwen Davis. ✨