Disclaimer: I am not the person who predicts the market. I am a junior backend developer who reads job postings, gets rejected, and adjusts. So treat this as field notes, not a forecast.

But there is one thing I am sure of, because I lived it this year: the hard part of my job stopped being writing the code. The hard part is reading what an agent wrote, at speed, and knowing whether it is right.

That is the skill worth building in 2027.

What actually changed

Two years ago, the bottleneck was typing. You knew what you wanted; producing it took hours. Agents compressed that to minutes.

The bottleneck moved. Now a model produces a plausible solution in forty seconds, and you have maybe three minutes to decide if it is correct, idiomatic, safe, and consistent with the rest of your codebase. If you cannot do that, the agent did not make you faster. It made you risky.

This is why "learn to prompt" is bad advice. Prompting is a skill measured in days. Reviewing generated code is a skill measured in years, and it is built on the same foundations everyone keeps telling you to skip: data structures, complexity, how a database actually executes a query, how TCP works, how a process fails at 3am.

An agent will write you a function that does a linear scan inside a loop and looks perfectly reasonable. If you do not know why that is O(n²), you ship it.

The five things I would focus on

1. Fundamentals, but for a different reason than before. Not to write code from memory, but to audit code you did not write. That is a different exercise. Reading EXPLAIN ANALYZE matters more than ever, because the agent will not run it for you with judgment.

2. Linux and the terminal, properly. Agents live in your shell. They run commands, read files, spawn processes. The developers who get the most out of them are the ones who already know what the command should have been. If you cannot debug a service that will not start, the agent's confident explanation will convince you of the wrong thing.

3. One agent, configured well. Not five installed and half-used. The difference between a mediocre and a good agent setup is not the model. It is context: what it knows about your project, what it can read, what it is allowed to do, and whether it remembers yesterday.

4. MCP, and how tools reach a model. The Model Context Protocol is how an agent talks to your database, your browser, your docs. Learning to wire one tool properly teaches you more about agents than ten tutorials.

5. Verification. Tests, diffs, reproductions. This is the whole game. An agent that cannot prove its work is a guess with good formatting. This is also the thing that makes you employable, because it is the thing that is hard to fake.

What I would stop doing

  • Collecting frameworks. Another JS meta-framework in 2027 is a commodity. Nobody is hiring for it specifically.
  • Watching "AI for developers" content without building anything. I did this for weeks. It is entertainment.
  • Learning tools that only work inside a vendor's IDE. Prefer tools that run in your terminal and own your files.

The setup I actually use

I run OpenCode v2, configured with Gentle-AI. Here is the reasoning, and then the exact install.

Why OpenCode. It is open source, it runs in the terminal, it is not tied to one model provider, and it is extensible through agents, skills, commands, plugins and MCP servers. If you are on Linux and live in a terminal, that combination is hard to beat. It also ships as a desktop app and a web interface if you want them.

Why Gentle-AI on top. An agent with no workflow forgets everything between sessions, has no opinion about your project, and cannot prove what it did. Gentle-AI adds three things: persistent memory (Engram), a workflow for how work gets done (ODD), and an evidence-based review step (RDD). It also gives your agent a large skills library that loads on demand.

Important, and the project says it plainly: Gentle-AI never installs an AI agent for you. It configures the one you already have. That is a good design, and it is worth knowing before you start.

Install OpenCode

Pick one method.

# curl (recommended on Linux) curl -fsSL https://opencode.ai/v2/install | bash 
# Homebrew brew install anomalyco/tap/opencode-v2 
# npm npm install -g @opencode/cli 
# pnpm pnpm add -g --allow-build=@opencode/cli @opencode/cli 

On Arch there is also an AUR package, paru -S opencode-beta, which tracks the beta channel.

sudo pacman -S opencode 

Check it:

opencode --version 

The first run opens the terminal interface. Before you ask it anything, connect a model:

/connect 

That opens the provider picker. You can bring your own API key, or use a subscription plan. Do not skip this and then wonder why the agent does nothing.

Install Gentle-AI

# macOS / Linux, script installer curl -fsSL https://raw.githubusercontent.com/Gentleman-Programming/gentle-ai/main/scripts/install.sh | bash 
# Homebrew brew install gentleman-programming/tap/gentle-ai 
# from source, needs Go go install github.com/gentleman-programming/gentle-ai/v4/cmd/gentle-ai@latest 

If you use go install, the binary lands in $(go env GOPATH)/bin, which is not on your PATH by default. Add it once, then open a new terminal:

echo "export PATH=\"$(go env GOPATH)/bin:\$PATH\"" >> ~/.bashrc 

Then run the installer interface:

gentle-ai 

Gentle-AI installer interface selecting agents and components

It asks three things: which agents to configure, which components to install, and which persona to apply. You do not need Claude Code and Codex and Cursor at once. Start with OpenCode.

If you prefer flags over the interface, or you want to preview first:

gentle-ai install --agent opencode --dry-run 

--dry-run prints the plan and touches nothing. Use it the first time. When you are happy with the plan, drop the flag.

Then verify. doctor is read-only; it never changes anything:

gentle-ai doctor 

Gentle-AI doctor output

Back in OpenCode, the agent now has memory, a workflow, and a review step. It also keeps a snapshot of your config before every write it makes, which matters the first time you break something.

Updating both

Two independent things to keep current.

OpenCode updates itself:

opencode upgrade 

It detects how you installed it. If you installed with a package manager that owns the version, pass the method explicitly, for example opencode upgrade --method brew.

Gentle-AI depends on how you installed it:

# Homebrew brew upgrade gentle-ai 
# script installer — re-run it curl -fsSL https://raw.githubusercontent.com/Gentleman-Programming/gentle-ai/main/scripts/install.sh | bash 
# from source go install github.com/gentleman-programming/gentle-ai/v4/cmd/gentle-ai@latest 

Updating the binary is not the last step. Managed configs and skills have to match the new version:

gentle-ai sync 

sync rewrites the managed files, keeps your own settings, and leaves a backup. Then run gentle-ai doctor again. If you update only the binary and skip sync, you end up with a new CLI reading old prompts, which is the kind of problem that looks like a model bug and is not.

gentle-ai --version opencode --version 

What a session looks like

cd ~/projects/your-app opencode 

OpenCode terminal session working on a repository

The difference from a chat window is that the agent reads your repository, runs your commands, and edits files. Which is exactly why the next part matters.

The part nobody puts in the announcement

An agent with write access and no verification is a very fast way to introduce bugs you will not notice for a month. The first week I used one, I accepted a refactor that passed no tests, because there were no tests to pass.

So the workflow I would learn in 2027, in one line: make the agent prove it.

  • If the change is testable, write the test first and watch it fail. An agent that never sees a red test will happily ship a green one that tests nothing.
  • Read the diff. All of it. Not the summary.
  • Run the command yourself on the edge case the agent did not consider.
  • If it says "this should work", that is not evidence.

That is not a limitation of the tools. It is the job now.

A 90-day plan, if you want one

Days 1 to 15. Install OpenCode and Gentle-AI. Use them on one real project, not a tutorial. Break something and fix it.

Days 16 to 45. Pick one thing you already know well and make the agent do it, then review the result line by line. You will find something. That moment is the skill.

Days 46 to 75. Add one MCP server that connects the agent to something you actually use. Read how it works, not just how to install it.

Days 76 to 90. Write the setup down. A short post, a README, a dotfiles repo. Explaining your workflow is how you find out which parts of it are real.

Conclusion

In 2027, "I know React" is not a differentiator. "I can direct an agent to build something and prove it works" is, because it requires everything underneath: fundamentals, Linux, testing, judgment.

The tools will change. This post will be outdated before the year ends, and that is fine. The workflow it describes, memory, small steps, evidence, is the part that survives.

If you take one thing from this article, take the sentence from the Gentle-AI README that I keep coming back to: verifying beats generating.