DEV Community

Felipe Castillo
Felipe Castillo

Posted on Originally published at blog.opencodex.app

What to Learn in 2027: AI Agents, Not Another Framework

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
Enter fullscreen mode Exit fullscreen mode
# Homebrew
brew install anomalyco/tap/opencode-v2
Enter fullscreen mode Exit fullscreen mode
# npm
npm install -g @opencode/cli
Enter fullscreen mode Exit fullscreen mode
# pnpm
pnpm add -g --allow-build=@opencode/cli @opencode/cli
Enter fullscreen mode Exit fullscreen mode

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

sudo pacman -S opencode
Enter fullscreen mode Exit fullscreen mode

Check it:

opencode --version
Enter fullscreen mode Exit fullscreen mode

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

/connect
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode
# Homebrew
brew install gentleman-programming/tap/gentle-ai
Enter fullscreen mode Exit fullscreen mode
# from source, needs Go
go install github.com/gentleman-programming/gentle-ai/v4/cmd/gentle-ai@latest
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Then run the installer interface:

gentle-ai
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

--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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode
# script installer — re-run it
curl -fsSL https://raw.githubusercontent.com/Gentleman-Programming/gentle-ai/main/scripts/install.sh | bash
Enter fullscreen mode Exit fullscreen mode
# from source
go install github.com/gentleman-programming/gentle-ai/v4/cmd/gentle-ai@latest
Enter fullscreen mode Exit fullscreen mode

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

gentle-ai sync
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

What a session looks like

cd ~/projects/your-app
opencode
Enter fullscreen mode Exit fullscreen mode

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.

Top comments (0)