Back to blog

From Chatbot to Coworker: Demystifying the AI Engineering Stack for Junior/Mid-Level Developers

Picture by Gemini Nano Banana Pro
aiexperiment

This post is part of an experiment in AI-generated content. All the post content (except this note) was generated by an AI. Read the making of) to get all the details on how it was created.

If you’ve been coding for a while, you remember when “using AI” meant pasting a function into ChatGPT and hoping it didn’t hallucinate a library that doesn’t exist.

Fast forward to 2026, and the landscape is chaotic. You hear about Agents, MCPs, Orchestrators, and Skill files. It’s no longer just a chatbot; it’s an entire ecosystem.

For junior and mid-level developers, this shift is confusing. Are these just buzzwords for the same thing? (Spoiler: No).

This post breaks down the modern AI Engineering Stack into clear layers, explaining what each tool does and—more importantly—why you should care.

Part 1: The Stack (The “What”)

Think of the AI stack like hiring a new developer. You need a brain (intelligence), a handbook (context), a laptop (tools), and a manager (orchestrator).

Layer 1: The Foundation (The Brain)

  • Examples: Gemini 3 Pro, Claude 3.7 Sonnet, GPT-5.
  • What it is: This is the raw intelligence. It knows Python, it knows English, and it knows logic.
  • The Limitation: By itself, it has no memory of your project, no access to your terminal, and no hands to type code. It’s a “brain in a jar.”

Layer 2: The Context Protocols (The “USB-C” for AI)

To make the “Brain” useful, it needs to plug into your world. We now have standards for this, so we don’t have to write custom glue code every time.

MCP (Model Context Protocol)

Think of this as USB-C for AI.

  • Before MCP: If you wanted your AI to talk to your Postgres database or Slack, you had to paste schema dumps into the chat window manually.
  • With MCP: It’s a standard connection. You plug an “MCP Server” (like a GitHub or Postgres connector) into your AI client. Suddenly, the AI says, “I see you have a users table; should I query it?” It connects the brain to your external tools securely.

Context Files: AGENTS.md vs SKILL.md

This is where most developers get confused. They look similar, but they serve different purposes.

  1. AGENTS.md = The Project README for Robots

    • Goal: Project-specific Context.
    • Content: “This project uses Next.js 15. We use Tailwind for styling. Run tests using vitest. Never use any in TypeScript.”
    • Use Case: When the AI joins your repo, it reads this file to understand the rules of the house.
    • Source: agents.md

  2. SKILL.md = The Reusable Training Manual

    • Goal: Reusable Capabilities.
    • Content: A specific workflow, like “How to generate a PDF report” or “How to run a database migration safely.”
    • The Magic: These files use Progressive Disclosure. The AI only loads the title (“Migration Helper”) at first to save memory. It only reads the full manual if you ask it to help with a migration.
    • Source: agentskills.io

Layer 3: The Worker (The Agent)

  • Examples: Cline (formerly Roo Code), Windsurf, Cursor (Agent Mode).
  • What it is: An Agent is the “Brain” given “Hands” and a “Loop.”
  • The Loop: A chatbot just replies. An Agent enters a loop:
    1. Plan: “I need to edit auth.ts.”
    2. Act: It runs a CLI command to edit the file.
    3. Observe: It reads the terminal output. Did the build fail?
    4. Fix: “Oops, I missed a semicolon.” (Edits again).
  • Why it matters: You don’t have to copy-paste code anymore. The agent lives inside your IDE and edits the files for you.

Layer 4: The Manager (The Orchestrator)

  • Examples: VibeKanban, OpenDevin/AllHands.
  • What it is: As agents get better, one isn’t enough. You might want one agent fixing a bug on the frontend while another writes docs.
  • The Killer Feature (Git Worktrees): Tools like VibeKanban allow you to spin up multiple agents at once. Crucially, they use Git Worktrees to isolate them.
    • Agent A works on a feat/login branch in a separate folder.
    • Agent B works on fix/typo in another folder.
    • You (the human) sit at the dashboard, approving their Pull Requests like a Tech Lead.

Part 2: The Modes (The “How”)

Now that you know the tools, how do you actually use them? Most modern AI IDEs operate in three distinct “Modes.” Knowing when to switch is the difference between frustration and flow.

1. Ask Mode (The Librarian)

  • The Prompt: “Where is the authentication logic handled in this app?”
  • Behavior: The AI searches your codebase (using vector embeddings) and gives you an answer. It changes nothing.
  • Use for: Onboarding, understanding legacy code, or finding bugs.

2. Plan Mode (The Architect)

  • The Prompt: “Review user.ts and propose a refactor to make it thread-safe.”
  • Behavior: The AI reads files and thinks. It produces a structured plan or a markdown document, but it does not write code yet.
  • Use for: Big features. Never let an AI start coding without a plan—it will paint itself into a corner.

3. Agent Mode (The Builder)

  • The Prompt: “Execute the plan. Run the tests after every change.”
  • Behavior: The AI takes the plan, edits files, runs your terminal, and self-corrects.
  • Use for: Grunt work, boilerplate, and implementing well-defined tasks.

Summary: Your New Workflow

If you are a junior or mid-level dev, don’t try to use everything at once. Start here:

  1. Master Ask Mode: Stop searching StackOverflow; search your own codebase first.
  2. Add AGENTS.md: Create a file in your root folder. Tell the AI how your project works. You will see immediate improvements in code quality.
  3. Try an Agent: Use a tool like Cline or Windsurf. Give it a small bug to fix and watch it work.
  4. Explore Orchestrators: Once you are comfortable, look at tools like VibeKanban to manage multiple tasks in parallel.

The goal isn’t to let the AI replace you. It’s to promote yourself from “Coder” to “Architect.”

This post is part of an experiment in AI-generated content. All the post content (except this note) was generated by an AI. Read the making of) to get all the details on how it was created.