Agentic Engineering 101
Renew Home Workshop · February 2026
Josh Lehman & Eric Helal · Martian Engineering
📋 Agenda
| # | Topic | Who |
|---|---|---|
| 1 | Setting the Stage | Josh |
| 2 | Models & Harnesses | Josh |
| 3 | Context Engineering | Josh |
| 4 | The Agentic Loop: WSPR | Josh |
| 5 | Demo 1 — Full Loop | Eric |
| 6 | Demo 2 — Internal Tooling | Eric |
| 7 | Takeaways & Call to Action | Josh |
| 8 | Q&A | Both |
1. Setting the Stage
Practical patterns for building with AI — from people using it every day.
Before we get into models and workflows, a quick introduction.
About Us
Martian Engineering
- Writing code for 17 years
- 13 years professional software experience
- Previously: engineering leader at startups I founded
Martian Engineering
- Worked in applied legal technology for 10 years
- Experience with highly regulated corporate environments
- Writing code for 8 years
We’re not AI evangelists. We’re practitioners sharing what’s worked for us.
We Mourn Our Craft
This was on the frontpage of HN yesterday.
"I didn't ask for the role of a programmer to be reduced to that of a glorified TSA agent, reviewing code to make sure the AI didn't smuggle something dangerous into production… And yet here we are. The worst fact about these tools is that they work." — Nolan Lawson, "We Mourn Our Craft"
The Counterpoint
"I do not mourn... Now, I get to make beautiful things by speaking, guiding, and directing a system which is capable of handling the drudgery while I think about how to make the system wonderful and functional and beautiful… It was, for me, never about the code. It was always about making something useful." — iambateman, Hacker News comments
The Craft Has Moved up a level of abstraction
- Engineering as a discipline isn't going anywhere
- Personally, I find great joy in building the systems that build for me (Factorio, anyone?)
- You still need to create clear goals, coherent systems, and tight feedback loops.
- Agentic engineering makes the process faster, less tedious, and more creative.
2. Models & Harnesses
A quick lay of the land
The Two We Use Daily
Claude Code Opus 4.6
- Better at conversing & planning
- Fast feedback loop
- Strong tool use
- Preferred orchestrator
Codex GPT 5.3
- Better at precise code output
- High-quality execution
- Preferred executor
YMMV. Different people get different results. The "best" changes monthly.
How you set up context, delegation, and review
around it.
That's what the rest of this
workshop is about.
What RH has access to: Codex + Copilot with Opus 4.6. We'll demo both.
3. Context Engineering
"You must have high openness and low agreeability. When you find pain, address the pain — iterate your prompting — alleviate the pain. Follow the loop." — Claude
Three Levels of Context
- Personal Personal Prompt — who you are, how you work, your preferences.
- Repository Repo Prompt — repo conventions, libraries, patterns. (CLAUDE.md / agents.md)
- Situational Skills — workflow playbooks loaded only when relevant.
This Is Not New
Developers have always written documentation, comments, and onboarding guides for other engineers.
Same muscle — you just reap the benefit immediately now.
And you can have the AI write the docs for you; you just need to tell it what to capture.
Skills: The Shared Prompt Library
- Org-level: "How to create a PR at Renew Home" — every PR follows the same format.
- Repo-level: "How to set up a new service" — standard libraries, structure, in this monorepo.
- Personal: Your own workflows and shortcuts.
Skills live in a repo. Version-controlled. PRs to update them. "Use Node 24 instead of 22" → every agent picks it up.
The Compounding Loop
- Ask AI to do something.
- It does something unexpected.
- Ask: why? Then teach it the right way.
- Update the right place: your personal prompt, the repo prompt, or a shared skill.
- Repeat. Over time, results compound dramatically.
4. The Agentic Engineering Loop
WSPR (Whisper)
WSPR
Four phases for any nontrivial problem:
- W Whiteboard — Explore the problem. Clarify the idea. Write the spec.
- S Scope — Break into self-contained, delegable work units.
- P Perform — Delegate to workers. Orchestrate parallel streams.
- R Review — Test, validate, give feedback, iterate. Merge.
W Whiteboard
Exploratory
Your idea is vague.
- Start conversational
- Ask it to ask you hard questions
- Make it make you think
- When it solidifies → write the spec
Refinement
You know what you want.
- Get a second opinion
- Ask it to poke holes
- Use plan mode / "think critically"
- Catch oversights early
S Scope
Break the spec into self-contained units of work an agent can implement independently.
| Cloud | Local |
|---|---|
| GitHub Issues | pebbles/beads issues |
| Linear tickets | Plain markdown files |
| Jira cards | Built-in todos |
Cloud vs Local Work Units
Cloud issues often describe the problem (PRD/requirement), not the implementation.
Cloud (intent)
- Problem statement
- Acceptance criteria
- Priority, stakeholders, constraints
- Often no implementation detail
Local (implementation)
- Self-contained tasks agents can do
- Explicit dependencies
- Commands, files, tests, definitions
- Agent-readable context
Cloud issue → translate →
pebbles issues →
agent executes → PR →
update/close cloud issue
Why We Use Pebbles
- Dependency relationships — encode order and what blocks what
- Context in markdown — rich context right in the description
- Local to your repo — no external service, no network dependency
-
API designed for agents —
pb helpteaches agents to use it
You could use GitHub Issues, Linear, Jira, or plain markdown. The tool matters less than the pattern: self-contained, dependency-aware, agent-readable work units.
P Perform
The Orchestrator Pattern
- File issues / define tasks with your orchestrator.
- Spawn workers to implement them.
- Workers isolate work using git worktrees.
- Context-switch between active streams while they churn.
Make plans, file issues, delegate, integrate, repeat.
Why use an orchestrator agent?
- Remain focused on what needs to be done, not the implementation details
- Executor agents start with fresh context and clear scope
- Parallelize work without context overload
- Integrate continuously: smaller diffs, less drift, fewer conflicts
- Better traceability from requirement → tasks → PRs
Orchestration Is Becoming Industry-Standard
Agents are often better at managing streams of work than a person is.
- Claude Code Teams — built-in, Claude-only (brand new, beta)
- Codex App — built-in multi-agent for Codex
- Conductor — open-source GUI
- Maniple (our tool) — supports both Claude Code & Codex
This pattern is here to stay. We show specific tools, but the pattern is what matters.
Git Worktrees
A feature of git since 2015 — multiple working copies of a repo, each on a different branch:
- Full working directory, not just a branch pointer
- Work on multiple branches simultaneously
- Git prevents the same branch being checked out in multiple places
- For agents: Each worker gets its own isolated worktree — parallel work without conflicts
Every multi-agent tool uses worktrees under the hood: Codex app, Claude Code teams, Conductor, Maniple.
R Review
Testing
- Agents write extensive tests if you tell them to
- Think about test architecture: setup/teardown, isolation, frameworks
- Make testing part of your planning, not an afterthought
- "Write a test for this failure. Verify it fails. Then fix it."
Code Review
- Review your own PR — read the diff
- Give feedback to your orchestrator
- It translates feedback into new work units
- Hooks enforce pre-commit checks
When AI Assist Is Not Helpful
- Trivially, When you already know the codebase and have a very specific change in mind
- Importantly, When you have lost the theory of the program
"A program is a shared mental construct that lives in the minds of the people who work on it."
— Peter Naur, Programming as Theory Building (PDF)
AI development makes it uniquely possible to lose the theory of the program. If this happens, stop, read the code, regain your understanding.
5. Demo 1 — Full Loop
Ramping up on a foreign codebase
6. Demo 2 — Internal Tooling
The 2E TUI — built for Renew Home's own Slack bot
7. Takeaways
The Compounding Loop
Remember WSPR
- W Whiteboard — Explore. Clarify. Write the spec.
- S Scope — Self-contained, dependency-aware work units.
- P Perform — Delegate. Orchestrate. Context-switch.
- R Review — Test. Validate. Feedback. Merge.
What's something that introduces friction into your day that a piece of software could solve if it existed? Think TUI, CLI program, GH Action, script, etc.
Try building something off of the critical path for yourself or your team to build trust and experience with agentic engineering..
Keep the stakes low. Build reps. Learn the workflow before throwing agentic engineering into the hot loop of development.
Resources
-
martian-todos — demo repository with the devcontainer workflow
https://github.com/Martian-Engineering/martian-todos -
agentic-engineering-101 — prompts + skills used for the tools we demonstrated
https://github.com/Martian-Engineering/agentic-engineering-101
Q&A
Josh Lehman & Eric Helal · Martian Engineering