Agentic Engineering in Teams: Building Practices People Can Trust


Greetings, traveler!

An iOS team decides to use an AI agent for a small feature. The agent updates several SwiftUI screens, adds a service, writes tests, and opens a pull request. The build passes. At first glance, the experiment looks successful.

Then review begins. The change includes a new abstraction nobody requested, a test that verifies a mock instead of the application’s behavior, and a navigation change that affects a different flow. The developer who requested the work spends an afternoon separating useful changes from unnecessary ones. Another engineer wonders whether the team is expected to review pull requests like this every day.

This is a hypothetical example, but the tension is familiar. An agent can produce a lot of work before the rest of the team has agreed on how that work should be scoped, reviewed, or maintained. Introducing the tool is often easier than adapting the engineering process around it.

Give the team time to experiment, and make a developer responsible for every proposed production change. When someone rejects an agent-generated pull request, examine the reason: the objection may reveal a problem with the workflow.

Start with a problem the team already recognizes

A rollout becomes easier to evaluate when it starts with a specific source of friction. A team might struggle to reproduce navigation bugs, understand an unfamiliar module, or prepare test data for UI scenarios. Each problem suggests a different use of an agent and a different way to assess the result.

For example, an iOS team maintaining a modular application could start with a recurring task: adding an error state to a screen that loads data from an existing API. The task touches UI state, a view model, and tests, but it does not require changes to authentication or data migration. The team already knows roughly how such work is done and what a reasonable implementation looks like.

Before starting, write down what the experiment should improve. A useful goal might be to reduce the time needed to prepare a reviewable change without increasing review effort or introducing regressions. Agree on the boundary of the task, the checks it needs, and who will review it.

Select a small set of representative tasks before starting. Include the kinds of changes the team handles regularly, agree on how to assess them, and record every outcome, including attempts that fail or need substantial rework. Save examples of prompts, changes, review comments, and checks when the organization permits it, removing sensitive information as required. A few tasks can reveal problems, but the results will be preliminary.

Participation should include engineers with different levels of interest in AI. The goal is to learn where the workflow helps and where it creates extra work. A small voluntary pilot gives people time to reach their own conclusions before the team considers broader adoption.

Listen to the objections

Developers may resist agentic workflows for different reasons. Some worry about confidential code leaving the organization. Others have tried an assistant and found its output inaccurate or tedious to review. A developer may enjoy implementing features and dislike a process that turns most of the day into reviewing generated code. Concerns about job security can also be part of the discussion.

These concerns require different responses. A privacy question needs an answer about approved providers, data handling, and access controls. A complaint about review noise calls for smaller changes or different review settings. Worries about career development deserve a direct conversation about how the team expects responsibilities and skills to evolve.

Ask for a concrete example when someone says that an agent is unhelpful: What task was it given? What did it produce? How long did it take to verify? Could a different scope have helped? The answer may be that the agent is unsuitable for that task, or that the team’s context and instructions are incomplete.

Team leads should make it safe to report a failed experiment. If a developer expects to be judged for not using AI enough, they have an incentive to hide problems and accept weak output. Usage quotas and token consumption are particularly poor substitutes for evidence that the work improved.

Agree on a small set of working rules

An agent needs enough context to work in an existing project. Its instructions also need a clear scope. A short project-level instruction file can tell the agent where to find architecture documentation, how to run common checks, and which areas require additional review.

For a Swift application, a starting point could look like this:

## Project conventions

- Feature modules should depend on public interfaces of other modules.
- Keep navigation decisions in the existing routing layer.
- Follow the minimum deployment target defined by the project.

## Verification

- Run the relevant package tests for changed business logic.
- Build the affected app scheme when changing integration code.
- Report skipped checks and their reasons.

## Escalation

- Ask a maintainer before changing authentication, payment,
  persistence migration, signing, or release configuration.
- Do not add dependencies without explaining the need and tradeoffs.

This is an example to adapt, not a complete policy. The commands, deployment target, and ownership boundaries belong to the actual repository. Point to authoritative documentation rather than duplicating long sections that will become stale.

Instructions are guidance for the agent. They do not by themselves prevent access to credentials or enforce review. Repository permissions, protected branches, CI configuration, and credential management have to provide those controls.

Someone should own the instruction file. Changes to it deserve review because a seemingly small edit can affect many future tasks. When an instruction repeatedly causes confusion, improve or remove it. A rule that nobody maintains gradually becomes another source of misleading context.

Turn successful routines into shared Skills

Once a team has repeated a task successfully, it can package the procedure as a Skill: a reusable set of instructions and supporting materials. In an environment that supports Skills, an agent may load one automatically or through an explicit request, depending on the tool. A team may keep a Skill for investigating SwiftUI performance, preparing a pull request, or reproducing a networking failure.

A useful Skill tells the agent when to use it, what information to gather, which actions are appropriate, and how to report uncertainty. For a performance investigation, it might ask for the affected screen, a reproducible interaction, the device or simulator configuration, and measurements before suggesting a change. It should not promise an improvement merely because code was rewritten.

Keep the first version narrow. If the team has one reliable way to investigate repeated view updates, document that procedure before adding launch performance, networking, and memory analysis to the same Skill. Review any bundled scripts as executable code, and give them only the access they need.

Shared Skills also need maintenance. Assign an owner, keep them under version control, and test changes against a small set of representative tasks. Record known failure cases and compare the updated version with the previous one using the same model, tools, and evaluation conditions where possible. Results can change with the environment, so repeat the evaluation when those dependencies change. A Skill can make an agent more consistent, but it can also make the same mistake consistently if its instructions are wrong.

Developers should be able to suggest improvements based on actual work. A short example of where an instruction helped, or where it led to an irrelevant step, is more useful than collecting a large library of Skills that nobody evaluates.

Protect review capacity

An agent can prepare changes faster than a reviewer can understand them. If every generated suggestion enters the review queue, the team may move the bottleneck from implementation to review.

Set an expectation that the developer requesting a change reviews the diff before asking a teammate to review it. The author should be able to explain the behavior, identify affected modules, and account for changed or removed tests. Generated code should meet the same standard as any other contribution.

Pull requests should be small enough to discuss. Suppose a feature requires a new API endpoint, a state model, and a screen update. The work may fit in one coherent pull request, or it may be easier to review as a sequence of dependent changes. Splitting by layer is useful only when each change has a clear purpose and reviewers can understand the intermediate state.

The pull request description should state the user-visible change, relevant design decisions, checks performed, and remaining risks. If a simulator test could not be run, say so. A successful build does not prove that the new error state is readable at large text sizes or that the retry button works.

AI-assisted review can help identify omissions, but its output still needs triage. Ask for a focused review of a specific risk, such as whether a navigation change can present the same destination twice. For each finding, look for a plausible failure and supporting code. An unsupported suggestion to introduce another protocol or defensive branch is not automatically worth implementing.

Avoid automatically posting every generated observation as a comment for the whole team. A noisy reviewer can consume more attention than it saves, and a quiet reviewer can still miss a serious issue. Track whether its findings are useful before making it a mandatory step.

Use CI to verify changes and constrain access

CI is a good place to run repeatable checks against the proposed commit. For an iOS repository, those checks might include formatting, package tests, an application build, and selected UI tests. Their exact scope depends on the change and on the time and infrastructure available to the team.

A pull request affecting a string or a local visual detail may need a lighter set of checks than a change to login, payments, or persistence. For higher-risk areas, add targeted tests and involve the relevant maintainers. If a required check cannot run, record it as not run and state why. The change remains blocked unless someone authorized by the team’s policy accepts the exception, records the risk, and decides what follow-up is needed. For sensitive changes, the policy may require the check to pass before proceeding.

An agent can summarize failed logs, suggest likely causes, or prepare a patch for a developer to inspect. Keep the original job result available: a summary is easier to read, but it is not the build log or the test report. A retry that passes should also be interpreted in context; it may reveal a flaky test rather than a fixed defect.

AI jobs in CI need their own access policy. Run code from an untrusted pull request in an isolated, minimally privileged job without secrets or repository write access. If a separate trusted component posts review comments, give it only the permissions needed for that action and treat the data it receives as untrusted. Keep signing identities, production secrets, and deployment credentials out of jobs that do not require them. Treat logs and artifacts produced by the untrusted job as untrusted too: a later privileged job must not execute their contents.

Treat pull request descriptions, source files, logs, and tool output as data that may contain instructions aimed at the agent. Restricting the agent’s permissions limits what such content can cause it to do. Before sending code or logs to a model, establish which data the organization permits the provider to process and apply any required redaction or retention rules. A human should review proposed changes and retain control of merging and release operations according to the team’s normal policy.

Measure the whole path to a usable change

A faster first draft is helpful only if the team can review, verify, and maintain it at a reasonable cost. Measure the period from starting a task to an accepted change, including rework and review. For a pilot, a simple shared record is often enough:

  • Task type, scope, and whether an agent was used.
  • Time spent on implementation and on reviewing or correcting the result.
  • Checks performed, defects found, and any follow-up work.
  • Model or tool configuration and the approximate cost, where available.
  • A short note from the developer and reviewer about what helped or slowed them down.

Avoid comparing individual developers by raw output. Task difficulty, familiarity with the codebase, reviewer availability, and interruptions can vary substantially. Even a before-and-after comparison within one team can be misleading if the work changes during the experiment.

When practical, compare similar tasks across both approaches, or use a small set of representative tasks with known evaluation criteria. Include more than one attempt when agent behavior varies. Keep a few scenarios aside when refining a shared Skill so the team can check whether an apparent improvement carries over to work it was not tuned against.

Look at delivery and quality together: elapsed time, review load, escaped defects, and the cost of the tools. Ask whether developers can still explain and modify the result. A pilot may reveal that agents help with test setup but slow down unfamiliar architectural work.

Keep knowledge inside the team

Agent-generated code can pass its checks while remaining difficult for the team to maintain. The risk grows when a single request produces a large change and the explanation is accepted without inspecting the important decisions.

For significant changes, ask the author to walk a teammate through the data flow and the reasons for the main design choices. In an iOS app, that might mean tracing an API response through the repository and view model to the screen, including error handling and cancellation. If nobody can explain why a new layer exists, the team should investigate whether it is needed.

Pay particular attention to code that handles money, identity, personal data, and persistent state. The people responsible for those areas need enough understanding to diagnose failures and change the behavior safely. An agent can help investigate an incident, but operational knowledge should not depend entirely on one tool being available.

Written decisions help when they capture constraints and tradeoffs that are hard to infer from code. Keep them close to the relevant module and update them when the implementation changes. Pairing, review discussions, and incident follow-ups also spread knowledge in ways a generated document cannot replace.

Follow one task through the pilot

Return to the screen that loads data from an API. The team agrees that a failed request should show an error message and a retry button. Tapping retry should start a new request, show loading while it is in progress, and display the returned data if it succeeds. The existing routing and networking interfaces should remain unchanged.

The developer gives the agent the relevant module documentation and asks it to inspect the current loading flow before proposing changes. The agent may then implement the state transition and add tests for failure followed by a successful retry. The developer reviews the diff, checks that the tests exercise the view model’s behavior, and removes any unrelated changes before requesting a review.

CI runs the affected package tests and builds the app scheme. The team also checks the error and loading states in the simulator, including whether the retry control remains usable with larger text. The pull request records the commands and results, along with any checks that could not be completed. If a required test is unavailable, the team handles that through its exception policy.

After review, the developer and reviewer record their active time separately from elapsed time waiting for CI or feedback. They note corrections and follow-up defects as well as tool cost. These observations become one entry in the pilot, to be considered alongside the other preselected tasks. A single successful screen change cannot establish that the workflow improves the team’s overall delivery.

Decide what to expand

At the end of a pilot, review both the work and the experience of the people involved. Which tasks reached review sooner? Which produced useful tests? Where did reviewers spend extra time? Did the team encounter security or privacy concerns? Are the instructions and Skills maintainable?

Use the answers to choose a next step. The team may expand a successful workflow to another feature area, keep it optional for exploratory work, revise a noisy review bot, or stop using an agent for a class of tasks. Give each change an owner and a date to revisit it.

Agree on the standards every change must meet, the evidence reviewers need, and who can make decisions or accept risk. Within those boundaries, developers can choose where an agent helps them and bring what they learn back to the team.