Video summary

Devin AI Is the Future of Coding… Full Tutorial

Main summary

Key takeaways

Technology

Summary of the Tutorial (Technological Concepts & Features)

What makes Devin different

The tutorial contrasts Devin with other AI coding tools (such as Cursor, Claude Code, and GitHub Copilot) by emphasizing that Devin can function as a full, cloud-based “autonomous software engineer” that operates independently of the user’s machine.

In the video’s framing, a user can:

  • Provide a task
  • Close the laptop
  • Later return to a finished pull request (PR)

Cognition → a larger ecosystem

The tutorial describes Cognition (the company behind Devin) as expanding through the acquisition of Windsurf, described as acquired for $250M.

Instead of being just a single product, Devin is presented as evolving into an ecosystem, including:

  • Devin for Terminal (local CLI agent)
  • Devin Cloud (cloud VM agent)
  • Devin Review (AI code review for GitHub PRs)
  • Workflow features such as:
    • playbooks
    • scheduled sessions
    • Slack/Linear integrations

Devin for Terminal (Local Agent): Installation, Usage, Workflow

Setup / install / account / pricing

  • Mac/Linux: installation via a terminal command (shown in the video)
  • Windows: installation via a documentation-based installer button
  • Requires a Devin AI account
  • Pricing described:
    • Free tier: lower usage limits
    • Pro: $20/month
    • Higher tier: $200/month
  • The demonstration uses a 14-day Pro trial

Basic CLI operation

  • Starts via the devin command
  • Demonstrates:
    • Starting an interactive session
    • Exiting using /exit or Ctrl+C twice
  • Supports direct prompt execution from the command line using prompt flags, e.g.:
    • -p "Hello, world"
  • This enables automation-style usage.

Recommended development setup

The tutorial recommends pairing the CLI agent with a visual IDE/editor for inspecting and editing generated code (example shown: Windsurf, with mentions of VS Code/Cursor too).

Project / file scoping

  • Devin operates within the directory where you start it (the video uses a working folder)
  • Uses @ to list project files in the current directory
  • Shows referencing files like index.html and asking Devin to edit them (e.g., “make it cleaner and be orange theme”)

Edit-permission modes (how changes are applied)

Devin supports permission control via modes toggled with:

  • /mode (shows modes like normal / accept edits / bypass)
  • Shift+Tab to cycle modes

Mode behaviors:

  • normal: prompts before edits/actions
  • accept edits: more automatic, but may still request permissions for some actions (not fully hands-off)
  • bypass: automatically applies changes without asking

Session lifecycle + forgetting context

The tutorial notes that exiting or restarting may reset conversational context (common with agentic CLIs).

Commands mentioned:

  • /clear: clear conversation history
  • /new: start a new session

It warns that:

  • Models tend to perform better early in the context window
  • Near the end, they may forget or hallucinate

Model switching (cost/latency tradeoffs)

  • Default model described as Swe 1.6 (“Cognition’s own coding model”)
  • Switch models via /model
  • Examples mentioned include:
    • “frontier” models
    • other named models (e.g., “Opus”, “GPT 5.5”, “Claude”-family, “Deep Seek V4”)

Guidance given:

  • Use Swe 1.6 / faster options for quick/simple tasks
  • Use more capable models for harder reasoning

Quota mechanics mentioned:

  • “Fast” models consume quota faster
  • The UI shows remaining quota % and resets within a time window

Cognition SWE 1.6 rationale (agentic coding improvements)

The tutorial attributes improvements to SWE 1.6, including claims that it addresses issues in other models such as:

  • overthinking
  • sequential tool calling instead of parallel
  • preferring shell commands over tool-based actions
  • looping behavior

Example claim:

  • SWE 1.6 “used internal tools rather than bash,” improving speed

Session persistence (resuming prior sessions)

Devin supports resuming closed sessions:

  • devin -c: continue the last session
  • devin -r: list recent sessions to select from

Advanced Local Agent Features: agents.md, Compaction, Sub-Agents

agents.md (project rules/config persisted into context)

The tutorial demonstrates creating an agents.md file in the project root.

It claims Devin automatically reads this file into the agent’s context so instructions persist across sessions/restarts.

Examples of what to store in agents.md:

  • tech stack
  • product information
  • coding conventions (e.g., “use Tailwind”, “don’t call APIs inside useEffect”)

Demonstrated workflow:

  1. Generate a React landing page
  2. Ask Devin to create agents.md
  3. Start a fresh session and ask questions
  4. Devin answers using only what’s in agents.md

Context pressure + compaction

The UI indicates token/context usage.

When context fills, Devin can:

  • clear the session and restart, or
  • use compacting to summarize prior work into fewer tokens

Tradeoff:

  • compaction may reduce performance

Sub-agents (parallel background execution)

The tutorial introduces sub-agents as parallel agent instances.

Demonstrated scenario:

  • create multiple distinct landing page variants in parallel
  • manage sub-agents through UI navigation (sub-agent tab; foreground/background controls)

Background execution:

  • While sub-agents run, the main session remains usable
  • The tutorial mentions using Ctrl+B to move sub-agent output into the background

Devin Cloud (Cloud VM Agent): Handoff and Autonomous PR Creation

How local hands off to cloud

Devin Cloud runs via a web app at app.devin.ai.

Requirements include:

  • Devin account
  • connecting GitHub in settings (optionally specific orgs)

Local prerequisites:

  • Hand-off is performed from within a Git repo

Steps shown:

  • devin setup: connect Git provider
  • /hand off: send a prompt from CLI to Devin Cloud

Cloud behavior

Devin Cloud:

  • spins up a virtual machine
  • pulls the repo
  • executes tasks
  • makes changes
  • creates a GitHub pull request

The tutorial emphasizes persistence:

  • you can stop local work; the cloud agent continues

Devin Review (AI review for PRs)

After Devin Cloud creates a PR, Devin Review can:

  • analyze PRs automatically
  • leave review comments
  • indicate issues/severity (e.g., deprecated usage)
  • optionally propose or apply fixes

Demonstrated triggers/integration paths:

  • a Review button/flow in the PR UI
  • a domain shortcut rewrite to devinreview.com for reviewing accessible PRs

Cloud Workflow Automation: Environment, Knowledge, Secrets, Playbooks, Schedules, Slack/Linear

Environment setup (cloud agent configuration)

The video lists cloud capabilities for advanced repos, including:

  • Environment / snapshots / blueprints / repositories preloaded into the machine context
  • Knowledge injected into context (system or built-in knowledge)
  • Secrets used to provide environment variables for services
  • Playbooks as reusable prompts for repeated tasks
  • Schedules to run playbooks automatically (e.g., nightly codebase audits)

Integrations (team workflows)

Devin connections mentioned:

  • Slack
  • Linear
  • also Jira and Microsoft Teams (Slack/Linear emphasized)

Example of Linear workflow (as described):

  1. Connect Linear in Devin
  2. Assign an issue to Devin
  3. Devin creates a plan, waits for approval
  4. Then Devin transitions the issue workflow (e.g., backlog → in progress)
  5. Uses an MCP server for Linear (as described)
  6. Shows the cloud session can be opened/viewed live and continues after approval

Main Speakers / Sources (As Indicated)

  • Creator / presenter reference: “Tech With Tim” appears in examples, but the tutorial host/person is not explicitly named in the provided subtitles.
  • Primary products/services mentioned:
    • Devin (Cognition)
    • Windsurf (acquired by Cognition)
    • Devin Review
  • Tool mentioned during prompting: WhisperFlow (used by the presenter for formatted prompts)

Original video