Working as a developer often feels like an endless juggle. You manage complex codebases, fix bugs, and build new features. This juggling act often leads to burnout and slow progress. You might feel overwhelmed by the sheer volume of tasks. What if you could offload much of this work? What if you could become a true leader, guiding a highly efficient team of AI agents?
The video above introduces a revolutionary agentic engineering workflow. This workflow is designed by an L8 principal engineer. It transforms how you approach development. It promises to boost your productivity. You can ship 40 to 50 PRs every day. This is real production code, not just demos. Let’s dive deeper into building your own AI crew. We will explore how to make them work for you, not against you.
Building Your Ship: A Terminal-Centric Foundation
A strong foundation is key for any successful journey. For a high-speed agentic engineering workflow, this means a powerful terminal setup. Many prefer graphical user interfaces (GUIs). They offer rich visuals. However, a terminal-based approach offers unique advantages. It keeps your hands on the keyboard. This maintains your deep focus. Context switching is minimized. Your brain stays in the flow.
1. **WezTerm: Your Command Bridge**
First, consider your terminal emulator. WezTerm is a top choice. It is clean and elegant. It is also highly performant. Built by “Wez,” it boasts over 26,000 GitHub stars. It is truly cross-platform. WezTerm works identically on Windows, Mac, and Linux. This offers consistent workflows anywhere. You can customize nearly everything. Lua scripts allow dynamic configurations. Changes reload instantly. This makes personalizing your setup easy and efficient.
2. **Tmux: Your Multi-Pane Dashboard**
Next, you need to manage multiple tasks. Tmux, short for terminal multiplexer, is essential. It lets you split your terminal into many panes. You can run an agent in one pane. An editor can sit in another. You still have a pane for commands. Tmux also supports multiple tabs, or “windows.” This is perfect for running several agent sessions at once. A game-changing feature is session persistence. Detach from tmux. Reattach later. You return to your exact working state. This means your work can continue across devices. Even your phone can access your full session. Configuring tmux takes some effort. However, the benefits in productivity are immense.
3. **Neovim (Nvim): Your Precision Toolkit**
Finally, you need a fast text editor. Nvim is a modern version of Vim. Its design keeps your hands on the keyboard. Navigate with keys. Edit with commands. Want to delete a line? Type “DD.” Undo it with “U.” Relative line numbers speed navigation. Type “11K” to jump eleven lines up. Plugins enhance functionality. Search your codebase with ease. Find files quickly by name. Nvim has a learning curve. Once mastered, it feels incredibly fluid. You will “fly like a bird” through your code. This keyboard-driven efficiency minimizes interruptions. It helps you stay focused.
Recruiting Your Crewmates: Choosing AI Agents
With your ship assembled, it’s time to recruit your crew. These are your AI agents. They will handle much of the coding. The landscape of AI agents changes fast. Being “agent-agnostic” is smart. This means your workflow adapts to different tools. Here are popular agent harnesses:
1. **Claude Code:** This is a practical choice. Especially if you use Anthropic’s subscription. It offers sensible defaults. Its feature set is rich. Some minor bugs can appear. It is less customizable than other options.
2. **Codex:** Written in Rust, Codex feels very smooth. It is open-source. If issues arise, Codex can inspect its own code. It finds workarounds by itself. It has fewer bells and whistles. Customization is also limited.
3. **Pi Coding Agent:** This agent is minimal. It is highly extensible. Pi is great if you dislike bloat. It suits those who love to tinker. You can truly make it your own.
4. **Opencode:** Opencode boasts a buttery smooth UI. It integrates well with many models. It provides a more complete feature set than Pi. It’s a solid, model-agnostic choice. Grab it off the shelf and start working.
The video uses Claude Code for demonstrations. Remember, the core concepts apply to all agents. Focus on the “how” and “why,” not just the specific tool.
Ramping Up Your Crewmates: Memory and Skills
Your new AI recruits are fresh. They need proper onboarding. They must learn your ship’s rules. This is done through “memory files” and “skills.” These help agents understand your preferences. They also learn project specifics. This avoids repetitive mistakes.
1. **Memory Files: The Ship’s Logbook**
Memory files are critical. They store collective learning. They guide your agents. There are two types:
- Global Memory Files: These store universal preferences. They apply to every agent session. Keep them minimal. Why? Every line gets loaded into the system prompt. Too much content wastes tokens. For example, you might write: “Never use the em dash.” Or, “When making technical decisions, do not give much weight to development cost.” This corrects a common AI bias. AI models often overestimate human dev costs. They pick cheap, low-quality solutions. Your explicit rule corrects this. Another important preference: “Always start bug fixes by reproducing the bug end-to-end.” This promotes robust testing. It avoids insufficient unit tests.
- Project-Level Memory Files: These are project-specific. They contain context, repo layout, terminology, and testing instructions. You build these over time. When an agent makes a mistake, correct it. Ask it to “remember” the correction. Store this learning in the file. This makes your crewmates smarter. It builds their project experience. Over time, these files can grow large.
2. **Skills: Specialized Training Manuals**
Large memory files waste tokens. Agents load everything, even if not needed. Skills solve this problem. They offer “progressive disclosure.” An agent only loads a tiny description. It reads the full skill only when needed. This saves tokens. It optimizes efficiency. For example, move end-to-end testing instructions into a skill. They are only needed when making changes. Agents can even create skills for you. Use tools like `skill-creator`. Or the NPX skills CLI. It helps install and manage skills easily.
A Word of Caution: Be careful with external skills. Even popular ones. Many skills can run anything on your machine. This is a huge security risk. They might leak API keys or credentials. Some skills actually degrade performance. Andrej Karpathy Skills, with 177,000 GitHub stars, for example. It made agents use 5% more tokens. It also worsened results in Program Bench tests. Popularity does not equal effectiveness. Only install rigorously evaluated skills. Look for published proof of their claims. Build your own skills when possible. This ensures security and optimal performance.
Communicating with Your Crew: Voice and Efficient Tools
Talking to your agents should be seamless. It needs to be efficient. The way you communicate impacts productivity. Your agents also need the right tools. These tools must be designed for them.
1. **Voice Input: Speak Your Commands**
Voice input is a massive productivity booster. A Stanford paper shows talking is three times faster than typing. This reduces context switching. It speeds up command delivery. Tools like OpenSuperWhisper transcribe locally. It is free and open-source. The quality is exceptional. Use it for most prompts. Only type for URLs or file paths. Speaking a URL is often awkward. This simple switch dramatically increases your speed.
2. **AXI: Tools Built for Agents**
Agents rely on external tools. Their design profoundly affects agent performance. “AXI” stands for design standards. They optimize tools for agent ergonomics. They treat agents as first-class citizens. Consider accessing GitHub. Using the GitHub MCP server is inefficient. It costs three times more in tokens. It has more than double the latency. The CLI is far better. AXI principles make tools highly efficient. For example, token-efficient output formats save 40% of tokens compared to JSON. Examples include GitHub AXI and Chrome DevTools AXI. Always research tool efficiency. It maximizes your agent’s mileage.
3. **Lavish: Visual Planning and Feedback**
Planning complex tasks is crucial. Lavish-AXI is a vital tool. It aids in planning complex features. Instead of reading walls of text, Lavish visualizes options. It uses the project’s design system. This creates HTML artifacts. You see prototypes directly in your browser. It makes concept review easy. You can annotate specific parts. Give precise feedback to the agent. Make decisions by clicking options. Send feedback directly. This integrated feedback loop is highly efficient. It avoids endless back-and-forth text exchanges. Once happy, tell the agent to build. The planning phase clarifies all requirements. This leaves the implementation phase to the AI.
Automating Quality Control: The “No-Mistakes” Pipeline
AI writes code incredibly fast. Manually reviewing every diff creates a bottleneck. It caps your velocity. It’s also not enjoyable. Think like an engineering manager. Influence quality through systems. Let your agents handle the grunt work. The “no-mistakes” pipeline does exactly this. It ensures high-quality output. It reduces your review burden.
1. **From Code to Clean PR:** When an agent says its work is “done,” send the change to `no-mistakes`. This is a free, open-source tool. It orchestrates a series of steps. It turns first-pass code into a clean PR. It works in an isolated worktree. Your main repo stays unaffected. First, it understands your intent. It analyzes the agent session. It then rebases your changes. It resolves merge conflicts upfront. An adversarial review process begins. Most problems are caught here. Obvious issues are self-corrected. Ambiguous problems get escalated to you. After review, it tests the change end-to-end. Evidence is recorded for verification. This proves the change works as intended. Documentation is updated. Linting problems are fixed. Finally, the branch is pushed. A PR is raised for your review.
2. **Babysitting Your PRs:** `No-mistakes` keeps babysitting the PR. It handles new merge conflicts. It manages CI pipeline failures. This frees up your time. You don’t waste time on mundane issues. You only return when all checks pass. Then, you apply your judgment. The generated PR provides a summary. It details intent, changes, testing, and pipeline actions. Evidence from testing is available. You can see screenshots or videos. This gives direct proof of functionality. A risk assessment is also provided. For low-risk changes, you might skip diff review. The pipeline likely caught any issues. Focus your time on risky changes. This system scales your code changes. It maintains quality with a large AI crew.
Managing Long-Running Tasks and Parallel Work
As a captain, your goal is to free up time. You want to focus on strategy. This means keeping agents busy. They need to work on longer, more complex tasks. You also need to manage multiple projects at once.
1. **”Good Night Have Fun”: Long-Term Automation**
What if agents could work while you sleep? “Good Night Have Fun” is your solution. It’s a free, open-source tool. It handles long-running tasks. Give it an objective. Define stop conditions. It loops until goals are met. For instance, ask it to “act like a 7-year-old kid using an app.” Instruct it to “find the first usability problem.” Then, “fix it, and rinse and repeat.” You can monitor token usage. Track iterations. Watch commits stack up. Use it for verifiable objectives. Examples include reducing page load time. Improving end-to-end test coverage. Or automating research. This tool keeps agents busy. It frees you up for other things. You wake up to a list of completed commits. You choose which ones to keep.
2. **”Treehouse”: Managing Parallel Workspaces**
Running multiple agents in one directory causes conflicts. `Git worktree` is a default solution. It creates a clone of your repo. This separate directory allows isolated work. However, managing these worktrees manually creates overhead. You need to remember their purpose. You must remember to remove them. “Treehouse” simplifies this. It’s another simple tool. Run `treehouse` in your repo. It drops you into a fresh worktree. Spin up more worktrees as needed. Type `treehouse status` to see them. When you close a tab, `treehouse` frees that worktree. It reuses idle worktrees for efficiency. This system lets you manage many parallel sessions. It reduces mental load.
3. **Juggling Multiple Agents: The Art of the Captain**
With `tmux` and `treehouse`, you can run many sessions. Spin up agents for various tasks. One agent fixes a UI bug. Another investigates a server issue. A third works on a new feature. Use keyboard shortcuts to switch tabs. Monitor agent activity in the status bar. This parallelization significantly increases output. However, juggling many sessions can still be tiring. Constant context switching becomes a new bottleneck.
Your First Mate: Orchestrating the Crew
Juggling many parallel agent sessions gets exhausting. You need a “first mate.” This is an agent that manages other agents. It handles the overhead. You, the captain, focus on the big picture. This is how you truly level up.
1. **Introducing “Firstmate”: Your AI Manager**
Firstmate is a free, open-source project. Clone the repo. Run an agent within it. Now you talk to Firstmate. It manages all your projects. For example, tell it: “Add an update command to the CLI for three GitHub projects. Update their versions to the latest on NPM.” Firstmate understands. It sees these as three parallel tasks. It spins up `tmux` tabs. It calls `treehouse` for worktrees. It runs agents in each. It even uses `no-mistakes` for validation. All these PRs are prepared for you. Firstmate handles the juggling. You give it more work. “Review the most recent three open issues in this repo.” Firstmate analyzes. It identifies actionable items. It then addresses them on your command. Watching it context switch is satisfying. It frees you from this burden.
2. **The Captain’s Mindset Shift**
With Firstmate handling execution, your role changes. You might run out of ideas for tasks. This is a good sign. It means the bottleneck has shifted. Now, you must focus on understanding “what matters.” Talk to your users. Study the competitive landscape. Craft a clear “treasure map.” This guides your AI crew effectively. You transition from a sailor to a great captain. You steer the ship. The crew executes your vision. This is the ultimate agentic engineering workflow. It maximizes developer productivity. It makes software development enjoyable.
Deconstructing the Agentic Engineering Workflow: Your Questions
What is an ‘agentic engineering workflow’?
It’s a modern approach to software development where engineers leverage AI agents to automate and manage many coding tasks, aiming to significantly boost productivity and accelerate code delivery.
What are ‘AI agents’ in the context of this workflow?
AI agents are specialized artificial intelligence programs designed to perform various development tasks, acting as an automated ‘crew’ to write code, fix bugs, and manage changes under an engineer’s guidance.
What basic tools are recommended to set up this workflow?
A strong foundation includes a terminal emulator like WezTerm for consistent access, Tmux to manage multiple tasks and sessions within your terminal, and a fast text editor like Neovim for efficient code editing.
How do AI agents learn and remember information specific to a project?
AI agents learn through ‘memory files,’ which store global preferences and project-specific context, and ‘skills,’ which are specialized instruction sets that agents load only when relevant to a task.
What is the primary benefit of using an agentic engineering workflow?
The main benefit is a substantial increase in developer productivity, allowing engineers to offload routine coding tasks to AI agents and focus more on strategic planning, problem-solving, and overall project leadership.