Skip to content
Beyond AI Coding: How Amap's Search/Ad Team Builds Agent-Driven Delivery Pipelines
R&D Management 25 min read

Beyond AI Coding: How Amap's Search/Ad Team Builds Agent-Driven Delivery Pipelines

Amap's search, recommendation, and advertising team shares engineering practices using AI agents for cross-repo development, code refactoring, and real-device verification, structuring delivery into four stages—intent specification, context provisioning, traceable review, and continuous evaluation—to convert individual AI coding gains into sustainable team delivery capabilities, with concrete metrics and case studies.

Amap Tech
Amap Tech
Amap Tech

Introduction: From Individual AI Coding to Team Delivery

The widespread adoption of AI Coding is lowering the coding barrier and prompting a rethink of how R&D work is organized. Real business delivery requires understanding business problems, forming clear requirements, coordinating multiple roles and systems, and verifying results against expectations. Amap's search, recommendation, and advertising (search/ad/rec) team explores an AI Native approach centered on Agent Teams: letting agents handle more complete tasks while turning human experience, judgment, and practice feedback into reusable, improvable team capabilities.

This article series covers four themes: an overview of Agent Teams collaboration and supporting engineering mechanisms; delivery practices with Starship 10X for complex multi-repo tasks and Starship Cloud Agent for cloud execution; digital employee practices with Linglingqi for issue triage, business analysis, and proactive follow-up; and on-site practices with Qingzhou for product/design roles participating in product and frontend construction using cloud real devices.

Three Concrete Delivery Cases

Case 1: Four-Repo Collaboration — Unifying Business Semantics

A shop rental/sale category build involved four repositories: business service, product search, dictionary config, and guide recommendation. Each repo owned a piece—product type expression, content recall, config effectiveness, entry display—and all had to share a consistent understanding of the same business requirement.

The delivery agent first retrieved code to confirm responsibilities, call relationships, and existing constraints across the four repos. It reused existing product types and distinguished rental vs. sale via business categories. The design specified compatibility requirements and launch sequence, enabling parallel implementation per repo. Integration and release still followed dependency order to avoid intermediate states where the entry appears but downstream content is missing.

Metrics: 4 repos, 4 code review requests ( CR), 1,548 lines changed. Design checks 4/4 passed; smoke verification 3 passed, 1 skipped due to missing environment. Requirements input, design confirmation, and CR review involved humans; the rest was platform-driven. The 4 CRs were submitted July 3 and completed human review, integration, and archival by July 14. This highlighted the need to measure the full cycle from requirement acceptance to verification, and where time is actually spent.

Figure 1: Design, implementation, and verification flow for four-repo collaboration
Figure 1: Design, implementation, and verification flow for four-repo collaboration

Figure 1: Design, implementation, and verification flow for four-repo collaboration

Case 2: Two-Repo Refactoring — Failure-Triggered Repair and Re-verification

Adding a distance filter to the detail page's nearby search required unifying distance parameters across a large change surface while preserving legacy behavior. The task spanned guide recommendation and recommendation service repos: 2 CRs, 12,480 lines changed.

The agent retrieved existing page components and distance recall logic, determined reuse paths and change scope. The solution unified distance units and defaulted the new capability to off; when no distance tier was selected or parameters were invalid, it fell back to original behavior. With constraints clarified, both repos proceeded in parallel.

After the first smoke verification failed, the agent entered a repair loop: one fix cycle, then re-verification passed. Both CRs were then archived (code review remained human). Acceptance Test-Driven Development ( ATDD) found a concrete foothold here: acceptance criteria participated in decisions from design, verification failures drove implementation fixes, and modifications triggered re-execution of checks.

Figure 2: Failure localization, repair, and re-verification in two-repo refactoring
Figure 2: Failure localization, repair, and re-verification in two-repo refactoring

Figure 2: Failure localization, repair, and re-verification in two-repo refactoring

Case 3: Real-Device Verification at Scale — Actionable Check Results

A refactoring task covering 96 business modules used multiple agents to identify modules and batches, locate real entry points, complete code changes, and schedule cloud real devices to capture screenshots and results. Four execution batches produced 96 result files and 795 process screenshots. One interim check yielded 9 PASS, 47 FAIL, 40 BLOCKED; the task remains in verification and repair. PASS: check passed. FAIL: check found issues. BLOCKED: verification blocked by insufficient conditions.

Each state maps to a distinct next action: PASS moves to acceptance; FAIL triggers further repair; BLOCKED requires environment or execution condition completion. Clear state separation lets engineers know exactly what to pick up next.

In a search link UI refresh, the team also used before/after real-device comparisons from home page to list page to verify consistent continuous experience. Only when code changes land on real pages do layout, interaction, and link continuity become directly inspectable.

Four Interlocking Engineering Stages

Cross-repo development demands unified semantics; large-scale refactoring relies on explicit compatibility contracts; real-device tasks expose environment and acceptance gaps. The team structures one delivery into four connected stages: Intent, Context, Review, and Evaluation. The first three help complete the current task; evaluation feeds multi-task problems back into system improvement.

Stage Summary

Intent — Key Question: Are goals, scope, and acceptance criteria clear? Delivery Artifact: Executable spec, exception branches, open questions.

Context — Key Question: Are code, knowledge, and logs relevant and valid? Delivery Artifact: Context with source and applicability scope.

Review — Key Question: Does the current change meet next-stage requirements? Delivery Artifact: Change description, verification results, unverified items.

Evaluation — Key Question: Do improvements continuously raise task quality and efficiency? Delivery Artifact: Comparable task results, failure causes, improvement items.

Intent: Writing Implicit Requirements into Acceptance Criteria

If a rental/sale category requirement only says "add entry", implementation leaves huge guesswork: can product types be reused? Should it display when no supply exists? How to compat with existing entries? Writing these into the spec enables the agent to implement and reviewers to accept.

An executable spec must clarify business goal, task scope, key constraints, and acceptance method. Goal- and scope-affecting questions are judged by respective owners; compatibility, degradation, and exception branches are turned into checkable conditions where possible. Spec effectiveness is ultimately measured by whether it reduces repeated clarification during implementation, surfaces conflicts early, and supports acceptance.

Currently, the requirement insight agent is used for some search issue triage and assists with product prototypes and requirement docs. Requirement value judgment, requirement review, and handoff to engineering remain areas for further refinement.

Context: Making Business Experience Withstand Code Verification

Code shows how the system is implemented, but business goals, historical trade-offs, and exception handling conventions are not always fully captured in code. Agents need both. During cross-repo development, the agent verifies design judgments against code; when refactoring, it first retrieves existing implementations to determine reuse and modification paths.

Knowledge bases suit relatively stable architecture, rules, and interface contracts; task memory retains specific experiences, corrections, and preferences. Both must indicate source, applicability scope, and update time. After system changes, related conclusions should be re-verified to prevent stale docs or misstatements from affecting later tasks.

Retrieval must center on the current task, selecting relevant code, knowledge, and logs within existing permissions while preserving key sources. Dumping everything into context adds noise and makes errors harder to trace.

Failure example — POI name misalignment: Two points of interest on the map had names swapped with their locations. The requirement insight agent checked coordinates, recall, and accessed local rendering paths but missed the root cause. Human investigation later found the bug in a search-side code segment outside the agent's retrieval scope; relevant code and logs were not in its context.

This failure drove two improvements: retrieval coverage and conclusion credibility must advance together. When critical paths remain unchecked, the agent should state what information is missing, how to verify next, and hand off to humans when necessary. Only confirmed causes, invalid investigation paths, and effective methods should enter the knowledge base and regression suites. Subsequent re-verification with original and similar new tasks checks whether the agent locates problems more accurately and expresses unknowns more precisely.

Review: Tracing Every Conclusion to Concrete Changes

A review must connect requirements, implementation, and verification: what was originally promised, what was actually changed, which results are verified, what conditions remain unmet. Reviewers should trace from change description to code diffs, tool invocations, tests, and real-device results to judge if the task meets next-stage entry criteria.

In the four-repo task, per-repo design checks, cross-repo semantic alignment, and smoke tests each covered different gaps; the repo lacking environment retained an unverified state. Failure and repair records are equally valuable: in the two-repo task, why the first run failed, what was modified, and what the re-check covered should all accompany the final result for reviewers.

Diff summarization, rule checks, and verification result compilation can be delegated to agents. Business semantics, architectural trade-offs, major risks, and production releases remain human judgments. Multi-agent or multi-model cross-review adds perspectives, but conclusions must land on checkable code and runtime results.

Evaluation: Measuring Whether Improvements Persist in Later Tasks

Session analysis, ticket feedback, and follow-ups from the requirement insight agent reveal which stage problems appear in and whether users received effective help. Evaluation must map this feedback to actual resolution outcomes and include tasks that failed, required rework, or needed human takeover. Different tasks have different success conditions; session end or user satisfaction cannot substitute for problem resolution.

To compare an improvement, pick a task group with clear acceptance criteria, ideally fixing code snapshot, model version, and execution conditions. Separate tasks used for experience distillation from those used for effect validation; repeat similar tasks appropriately to reduce model variance and known-answer bias.

The team also separates "fixing the current task" from "reducing errors next time." The two-repo auto-repair solved the immediate delivery; experience reused by later tasks, reducing repeated errors or human effort, demonstrates reuse value. Therefore, experience formation, invocation, and subsequent outcomes must be linked.

Collaboration Framework: Specialized Roles on a Shared Delivery Pipeline

The team explores three collaboration directions: requirement insight (problem discovery and requirement assistance), complex engineering (cross-repo implementation and verification), and product experience (prototyping, frontend, and experience checks). They connect on a shared execution environment and knowledge base, gradually stitching the flow from requirement to delivery.

Figure 3: Multi-agent R&D collaboration framework schematic
Figure 3: Multi-agent R&D collaboration framework schematic

Figure 3: Multi-agent R&D collaboration framework schematic

Handoff is the first collaboration challenge. At task start, share goal, scope, and acceptance criteria; at delivery, communicate current state, artifacts, and verification results; when issues arise, record failure causes and correction suggestions. This lets subsequent agents continue from existing work, reducing re-explanation of requirements or missed constraints.

The runtime environment must support pause, resume, rollback, and re-run, plus association of key decisions, tool calls, and results. One execution's records serve both immediate debugging and later knowledge maintenance and system evaluation.

Tooling prefers reusing mature capabilities like Codex and Claude Code, focusing team engineering investment on business context, real verification environments, cross-system collaboration, and feedback loops. Every added platform layer must justify the specific problem it solves and its cost and latency.

Human roles adjust accordingly: business owners confirm goals and boundaries; engineering owners judge solutions and dependencies; quality owners maintain acceptance and evaluation standards; knowledge maintainers handle content updates and invalidation. These roles can be filled by existing members. For recoverable, easily checked operations, auto-execution scope can expand gradually; critical trade-offs, high-cost actions, and production releases remain human responsibilities.

Measuring Engineering ROI by Delivery Outcomes

As task types grow, the team has practiced cross-repo implementation, failure recovery, and partial real-device verification. Next steps: fill gaps in testing, release, and multi-repo onboarding per task type; define how far each task type goes and who picks up the next step.

Scale as of August 2026:

Requirement Insight & Feedback : 257 users, 57 groups, 1,500 cases

Complex Engineering Delivery : 86 code repos, 16 MCP s, 36,000+ invocations

Real Environment Verification : 96 modules, 100 cloud real devices, 18 device models

With scale, the team focuses on per-task-type delivery performance: has requirement-to-acceptance time shortened? Have rework and human takeovers decreased? How does cost per qualified delivery task change? Four dimensions are tracked continuously:

Delivery Efficiency — Key Metrics: Requirement-to-acceptance/release cycle, review wait, human investment. Statistical Caliber: Compare by task type, difficulty, completion stage; unified time window.

Delivery Quality — Key Metrics: Acceptance pass rate, rework, regression, production issues. Statistical Caliber: Explicit quality standards, denominator definition, unverified items.

Experience Reuse — Key Metrics: Repeated clarifications, repeated errors, human takeovers. Statistical Caliber: Link experience invocation to subsequent task results.

Comprehensive Cost — Key Metrics: Total cost per qualified delivery task. Statistical Caliber: Include model, compute, retries, review, rework costs.

Currently, the team can replay specific tasks from submission through repair to acceptance. Answering overall team efficiency gains requires continuous comparison on similar task types and difficulties, especially checking whether coding time saved is consumed by review, integration, or rework.

Rollout follows the same rhythm: start with tasks that have clear boundaries, easily checked results, and recoverable operations to accumulate experience; for core business logic, complex cross-repo dependencies, and high-risk releases, complete corresponding verification before expanding auto-execution scope.

Feeding Experience into the Next Delivery

Next phase aims to curate verified cross-repo conventions, troubleshooting methods, and acceptance cases into maintainable, searchable shared knowledge. An interface convention reusable in the next requirement, an error root cause turned into a subsequent check item, a suite of acceptance cases that keeps catching regressions — these give individual experience a path into the team's daily work.

For the search/ad/rec team, smoother R&D delivery creates conditions for faster business experimentation. The goal is to continuously shorten the distance from business idea to verifiable result, letting engineers focus more on business judgment, solution selection, and outcome improvement.

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

R&D managementAI codingAmapRequirements EngineeringAgent TeamsContinuous EvaluationCross-repo DevelopmentReal-device VerificationSearch Advertising RecommendationTraceable Review
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.