Next
Generation
Development
Teams

How AI changes
the way engineering
teams work.
Research · Plan · Implement
Review · Test · Debug · Monitor
Dennis, VP of AI at Elementor
Elementor · Tel Aviv
Introduction
Dennis Nerush

VP of AI
at Elementor

How I got here
Ofek
01
Sears Israel
02
HiredScore
03
Elementor
04 · Today
Where We're Going

Eight Parts

I
The Shift
What actually changed — and what didn't
V
Rebuild The Lifecycle
Idea to production, stage by stage
II
AI Is A Team Sport
We optimised the individual, not the team
VI
Autonomy Without Chaos
More autonomy needs more verification
III
Context Is Infrastructure
Stop re-explaining your codebase every session
VII
The Next Generation Team
Before and after, side by side
IV
Meet Your New Team
Agent roles, and how you actually define them
VIII
Start Tomorrow
One capability, not twenty agents
Before We Start

Let's Get To Know
How You Work

Scan it on your phone.
It takes about a minute.

menti.com/alsvhjh92hzt
The Vision

Humans No Longer
Write Or Review Code.

That is the destination everyone keeps describing.
Nobody is there yet. This talk is about the road — and about who stays accountable while we walk it.

I
Part One

The
Shift

What actually changed — and what didn't.

AI Can Write Code. So What?

Coding faster is useful. But if that is the only thing that changed…

Before — where a feature's time actually goes
Spec
Code
Review
Test
Ship
With AI writing the code — same total
Spec
Code
Review
Test
Ship
Specs
Run Dry
Engineers now implement faster than anyone can define what to build.
Review
Queue
A PR written in an hour waits two days for a human to read it.
Regression
Surface
More merged changes every week, through the same QA gate.
Release
Train
Work piles up at a deploy cadence that did not get any faster.

…you didn't remove the constraint. You moved it somewhere with no AI pointed at it yet.

Ask the room
The Question

What If We Built
The Team Today?

If you were building your engineering team from scratch today, knowing what AI can do — would you design it the same way?

Hands up — who would build it differently?
AI can already
Research
Plan
Implement
Review
Test
Debug
Monitor
The Gradient

From Assistance
To Delegation

01
Manual
I implement the feature
→
02
AI‑Assisted
AI helps me implement it
→
03
AI‑Delegated
AI implements it, I review
→
04
Agentic
AI plans, implements, verifies and iterates
→
05
Ambient
It starts without anyone asking
The Shift Nobody Announces
An engineer opens a chat and types a prompt.

Nobody Opens A Chat

on: pull_request
Review, visual proof, test plan.
on: alert.fired
Investigate, reproduce, propose a fix.
on: issue.labeled(bug)
Locate it, draft the PR, tag an owner.
on: schedule(02:00)
Dependency audit, flaky-test sweep.
on: deploy.succeeded
Smoke the critical paths, report back.
on: branch.pushed
Keep the docs honest with the code.
The work starts without anyone asking.
Where The Work Moves
Write a better prompt.

Improve The Loop

Tune the
trigger
When should this fire, and when is it just noise?
Sharpen the
definition
What it blocks on, what it ignores, what it outputs.
Tighten
verification
How the system catches the agent being wrong.
Measure the
outcome
Did it actually save the team time, or just make noise?

A better prompt helps you once. A better loop helps the team every day this week.

Framing
The goal is not: “Use AI more.”

It Is: Build A More
Capable Engineering Team

Higher throughput
Shorter feedback loops
Better quality
Less repetitive work
II
Part Two

AI Is A
Team Sport

We optimized the individual. Now optimize the team.
The Problem Today

Five Engineers.
Five Private Setups.

ENG_01
own prompts
own tools
own conventions
ENG_02
own instructions
own workflow
own prompts
ENG_03
own tools
own conventions
own instructions
ENG_04
own workflow
own prompts
own tools
ENG_05
still figuring
it out
alone

We optimized the individual, not the team.

Ask the room
The Translation

Individual Discoveries Become
Team Capabilities

My prompts
→
Our skills
My instructions
→
Our standards
My context
→
Shared context
My agent
→
Team capability
What do you do with AI that nobody else on your team knows how to do?
The objective
Not every engineer needs to discover the best workflow independently.
Make useful discoveries reusable by the whole team.
The Operating Rhythm

Compound Your Team's Learning

This field changes every week. No individual can keep up with it — a team can.

Discover
→
Demonstrate
→
Standardize
→
Automate
Demo
Slot
Ten minutes. One thing you got an agent to do that you couldn't last month.
Weekly
Skill
Review
Skills and agent definitions get reviewed like code — because they are code.
Every PR
Tooling
Channel
New harness, new model, new MCP server. One place, low ceremony.
Always on
Ecosystem
Scan
Someone owns reading the release notes so twelve people don't have to.
Monthly

One engineer discovers. The whole team levels up.

III
Part Three

Context Is
Infrastructure

Stop re-explaining your codebase every single session.
Mental Model

The Model Is Only
One Part Of The System

Model
Raw capability
×
Context
What it knows about you
×
Tools
What it can act on
×
Workflow
How work is shaped
×
Verification
How you catch mistakes

A better model helps. It is not the entire system.

Every Session Starts Over

Stop Teaching AI
From Scratch

“Here's how our architecture works…”
“Here's how we write tests…”
“Here's how this service works…”
“Here are our coding conventions…”
Make that knowledge persistent and reusable.
Shared Infrastructure

Build A Team
AI Repository

/agents
developer
reviewer
tester
domain-expert
/skills
implement-feature
investigate-bug
review-pr
write-tests
/context
architecture
conventions
domain
 

The exact structure isn't important. The principle is.

Treat AI Capabilities
Like Code

Version them
Review them
Improve them
Share them
What A Skill Is

Skills Are
Reusable Knowledge

“This is how we investigate production incidents.”
— explained again, by hand, every time
→
/skills/investigate-incident
Written once.
Owned by the team.

Now it belongs to the team, not to one person's chat history.

Example · A Skill

This Is The Whole Thing

/skills/investigate-incident.md
---
name: investigate-incident
description: Use when an alert fires or a
  customer reports a production bug.
---

1. Pull the alert window from the dashboard.
2. git log --since on the owning service.
3. Correlate deploys with the error-rate change.
4. Reproduce against the staging snapshot.
5. Write findings before proposing a fix.

Never restart the service before capturing logs.
01
A triggerSo the agent knows when this applies without being told.
02
The stepsThe order your best engineer would actually follow.
03
The hard ruleThe mistake someone already made once. Now nobody repeats it.
Example · Skill Craft

Writing Them Well Is A Skill Itself

Vague · produces vague agents
/skills/review-pr.md
Review the pull request carefully
and give good feedback.

Be thorough and check for bugs.
Sharp · produces a useful reviewer
/skills/review-pr.md
Use when: a PR touches src/api or src/auth.

Read the diff, then the tests, then the
callers of every changed function.

Block on: missing authz, unparameterised
SQL, public API change with no migration.

Ignore formatting — the linter owns it.

Output: file · line · severity · fix
What made the difference
Name the trigger
Name what to ignore
Name the output shape
Example · Decision Context

Commit The Why, Not Just The What

features/checkout-v2/DECISIONS.md
# Checkout v2 — Decisions

## 2026-03-04 · Idempotency keys over DB locks
Chose client-supplied idempotency keys.
Rejected row-level locks: deadlocks under retry storms.
Owner: @payments

## 2026-03-11 · No new payment provider
Deferred until Q3 volume numbers land.
Owner: @dennis

<!-- committed in the same PR as the feature -->
01
Lives with the codeSame PR, same review, same history. It cannot drift into a wiki nobody opens.
02
Records the rejected optionThis is the part that stops the same debate happening twice.
03
The agent reads itSix months later it knows why, not just what.
IV
Part Four

Meet Your
New Team

Roles, not magic.
Definition

What Is An Agent?

Agent
=
Model
+
Context
+
Tools
+
Goal
+
Loop

Not magic. Not just a long prompt.
It can inspect the environment, take actions, observe results and iterate.

The Roster

Your Digital
Engineering Team

Human
Engineer
Owns Intent
Developer
Agent
Reviewer
Agent
Test
Agent
Security
Agent
Domain Expert
Agent
Role 01

The Developer Agent

Explore
→
Plan
→
Implement
→
Run
→
Inspect
→
Fix
Loop until it actually works
The important shift
Don't tell AI how to write every line.
Give it a goal and an environment it can work in.
Role 02

The Reviewer Agent

A reviewer that already knows:

Your architecture
Coding standards
Security requirements
Common mistakes
Testing expectations
And reviews every change consistently.
Role 03
“Who knows how this system works?”

Ask The System.

The agent can understand
Code
Architecture
Documentation
Decisions

Especially powerful for onboarding and legacy systems.

Example · Agent Definition

An Agent Is A File

/agents/reviewer.md
---
name: reviewer
tools: [read, grep, run_tests]
context: [architecture.md, conventions.md]
---

Block the merge on:
  - missing authorization on a new route
  - SQL built from unvalidated request input
  - public API change with no migration note

Never comment on formatting. The linter owns that.

Output: file · line · severity · suggested fix
01
It is in your repoVersioned, reviewed and improved like any other file.
02
It says what not to doScope is what makes a reviewer useful instead of noisy.
03
Nobody sold you thisYou wrote it on a Tuesday. You can change it on a Wednesday.
Example · Specialised Review

One Reviewer Becomes Four

Syntax
& Style
Naming, dead code, imports, test hygiene.
Comment only
Architecture
Layer boundaries, coupling, the abstraction nobody needed.
Must answer
Security
AuthZ on new routes, injection, secrets in source or logs.
Blocks merge
Performance
N+1 queries, unbounded loops, bundle-size regressions.
Must answer
The point
You choose the reviewers. You choose what blocks.
That is a line in a config file, not a vendor's pricing tier.
Example · The Harness

And It Runs In Your CI

.github/workflows/agent-review.yml
name: agent-review
on: pull_request

jobs:
  review:
    strategy:
      matrix:
        agent: [syntax, architecture, security, perf]
    steps:
      - uses: actions/checkout@v4
      - run: |
          cursor-agent -p "$(cat .agents/reviewer-${{ matrix.agent }}.md)" \
                       --output-format json > out-${{ matrix.agent }}.json
      - run: ./scripts/post-findings.sh out-${{ matrix.agent }}.json
01
The matrix is the trickAdding a reviewer means adding one markdown file and one word.
02
Your CI already does thisNo new platform, no new bill, no new vendor to onboard.
03
Swap the harness freelyCursor CLI here. Any agent CLI and any model behind it.
V
Part Five

Rebuild The
Lifecycle

Idea to production, stage by stage.
The Shape Of The Work

The Software
Development Lifecycle

Idea
01
→
Refine
02
→
Design
03
→
Code
04
→
Review
05
→
Test
06
→
Deploy
07
→
Observe
08
→
Learn
09
↺ and around again

Let's Redesign It.

Stage 01

Refinement

Today
Ticket
→
Meeting
→
Questions
→
Research
→
Another Meeting
→
Ready
With AI
Ticket
→
Agent
→
Context
→
Edge Cases
→
Dependencies
→
Acceptance Criteria

The human reviews the result instead of assembling it.

Stage 02
“Implement this ticket.”

Plan Before You Code

01
Understand
→
02
Explore
→
03
Plan
→
04
Review Plan
the human checkpoint
→
05
Implement

A wrong plan is cheap to fix. A wrong implementation is not.

Stage 03

Implementation

Task
Developer Agent
Explore codebaseImplementBuild Run testsInspect failuresFix
Working Change
Stage 04

Code Review

Old workflow
Developer
→
Reviewer
→
Comments
→
Developer
→
Reviewer
New workflow
Developer Agent
→
Reviewer Agent
→
Fix
→
Verification
→
Human
Humans spend their attention on
Architecture
Trade-offs
Intent
Risk
Example · Visual Proof

Stop Imagining What Changed

01
PR opened
↓
02
Boot the branch
↓
03
Drive the changed screens
↓
04
Capture before / after
↓
05
Post it on the PR
agent-visual-proof commented · 2 minutes ago
3 routes changed. Captured at 1440×900, light and dark.
Before · /checkout
After · /checkout
Order total moved to the right rail. Intended?

A reviewer who can see the change approves it in a minute, not a day.

Stage 05
“Write unit tests.”

Give The Agent
Responsibility

01
Understand Change
02
Identify Risks
03
Create Test Plan
04
Implement Tests
05
Execute
06
Investigate Failures
Stage 06

The Lifecycle Doesn't
End At Merge

⚠ Alert
→
Investigation Agent
Logs
→
Code
→
History
→
Hypothesis
→
Reproduce
→
Proposed Fix

AI becomes part of operations, not just coding.

VI
Part Six

Autonomy
Without Chaos

The part everyone skips.
Just let the
agent do it
— every demo you have ever watched
The Counterweight
00
Agent
↓
01
Compiler
↓
02
Lint
↓
03
Tests
↓
04
Security Checks
↓
05
Reviewer
↓
06
Human

More Autonomy
Requires More
Verification

Not more trust.

Every layer you add is a place the system can catch itself being wrong before a human has to.

Example · Earning Trust

The Approver That Doesn't Approve

01
Observe
Records the verdict it would have given. Posts nothing.
02
Advisory
Posts a check that cannot block. The team reads it and tunes the agent.
214/230
agreed with the human reviewer
0 false approvals
.agents/approve.yml
mode: advisory        # observe → advisory → enforce
post_check: true
blocks_merge: false   # ← the flag that matters
record_verdict: true

promote_when:
  agreement_with_human: "> 0.95 over 200 PRs"
  false_approvals: 0

Earn the merge button with data, not with optimism.

Example · Meta-Verification

Who Reviews The Reviewer?

Agent reviews
all week
→
Sample 20
at random
→
Human grades
agree / miss / false
→
Update the file
one new rule
→
Sharper reviews
next week
↺ every Friday, 30 minutes
Week 12 · 20 sampled · 17 agreed · 2 missed · 1 false alarm
Missed twice → added one rule: flag N+1 queries in serializers.
VII
Part Seven

The Next
Generation Team

Before and after.
Before

The Old
Development Team

Ticket
⏳Human
Code
⏳Human
Review
⏳Human
Test
⏳Human
Deploy

Everything waits for someone's attention.

After

The Next Generation
Development Team

Human
Accountable
Research
Implementation
Review
Testing
Security
Operations

The human owns

Intent · Architecture
Decisions · Judgment
Accountability

Agents handle

Research · Implementation
Validation
Repetitive work

For An Open-Model World

Your Model Is Not
Your Strategy

You do not need access to every frontier model to build a genuinely capable engineering system.

Don't make it about which model wins. Make it about engineering the system around the model.

01Open models
02OpenCode / agent harness
03Tools
04Context
05Skills
06Verification
↓
A capable AI engineering system
VIII
Part Eight

Start
Tomorrow

One workflow. Not twenty agents.
Where To Begin

Don't Build
20 Agents

Start with one repeated workflow.
Something your team already does every week.

For example
PR Review
Bug Investigation
Ticket Refinement
Test Generation
Domain Q&A
The Recipe

Build One Capability

Workflow
01
→
Context
02
→
Skill
03
→
Agent
04
→
Verification
05
→
Share
06
→
Measure
07
Then improve it

What Are You Still Doing
Manually Today That AI
Could Already Be Doing
For You?

Dennis Nerush
Dennis Nerush
dennisnerush.com
Scan for this slide
Edit mode — click any text · Ctrl+S saves a copy · E to exit