Skip to main content
Agentic Coding

Professional software development after manual coding

A disciplined way to build softwarewith coding agents.

Use coding agents across planning, challenge, implementation, and agent-operated evidence. Developers supervise the proof, direct deeper audits when risk demands them, and own acceptance and publication as separate decisions.

Start with the foundationSee the workflow
change/organization-api-keyscontrolled execution
  1. 01Developer

    Intent

    Add organization-owned API-key rotation within the existing credential system.

  2. 02Together

    Plan + Challenge

    Extend the existing credential boundary, then attack its assumptions before approval.

  3. 03Agent

    Execute

    Implement the approved slice with ownership checks and focused regression tests.

  4. 04Agent-operated

    Evidence

    Build and attack the evidence. The developer governs the proving system and decides.

Agent-operated. Developer-governed. Acceptance and publication remain separate decisions.

01 / The operating model

The difference is control, not line count.

An agent may write most of the implementation and the work can still be deeply engineered. What matters is who controls the decisions, scope, evidence, and quality.

AI made code generation cheap. Engineering did not become optional.

Code can arrive in seconds. The real question is whether the process can consistently turn that capability into software worth maintaining.

operating-model.matrixcontrol determines the mode
How manual coding, Agentic Coding, and vibe coding differ across the engineering lifecycle.
DimensionManual codingAgentic CodingVibe coding
PlanningDeveloper-led and developer-executedDeveloper and agent investigate togetherOften compressed into the initial request
ArchitectureDesigned directly by the developerProposed, challenged, and approved collaborativelyFrequently delegated with the implementation
ImplementationMostly written by the developerBroadly delegable within approved boundariesBroadly delegated toward a visible result
ContextHeld and explored by the developerInspected widely enough to understand the affected pathOften limited to the prompt and immediate files
VerificationDeveloper runs and interprets checksAgent operates most checks; developer challenges the evidenceVisible behavior may be the primary signal
ReviewDeveloper reviews their own or others’ workAgent reviews fully; developer audits by risk and decidesMay stop when the result appears to work
PublicationDeveloper performs the external action directlySeparately authorized after acceptance for one exact destinationMay follow automatically from apparent completion
ResponsibilityDeveloperDeveloperStill the developer, even when inspection is light
Primary goalDirect control through direct executionMore leverage without surrendering disciplineReach a result with minimal process overhead

A working definition

A collaborative discipline, not a shortcut.

Developers use coding agents throughout the work while retaining responsibility for intent, system direction, and engineering quality.

Across the lifecycle
Plan, challenge, implement, verify, and correct.
Under direction
The developer owns goals and tradeoffs.
Closed by evidence
Independent tests, agent review, and developer judgment earn confidence.

02 / Engineer the contract

Reliable delegation has layers.

Strong coding instructions do more than describe style. They connect authority, repository evidence, ownership, coherent implementation, adversarial proof, and external action into one engineering contract.

engineering-contract.layersone coherent state
  1. LAYER 01who may act

    Authority

    Dispatch explicit commands before ordinary intent, then preserve the developer’s stated objective, constraints, and acceptance criteria.

  2. LAYER 02what is true

    Evidence

    Inspect the relevant repository first and resolve decisions through safety, current contracts, local patterns, and installed tooling.

  3. LAYER 03where work belongs

    Ownership

    Extend the module that already owns the behavior, reuse established boundaries, and avoid parallel public contracts.

  4. LAYER 04what stays aligned

    Coherence

    Deliver production behavior with its validation, tests, errors, documentation, migrations, and verification in one consistent state.

  5. LAYER 05what proves readiness

    Judgment

    Challenge plans before execution, attack the evidence after it, and let the developer decide whether the result is acceptable.

  6. LAYER 06what may leave

    Publication

    Treat commits, pushes, deployments, releases, and other external actions as separate authority boundaries.

03 / Collaborate on the work

Plan together. Challenge assumptions. Execute in bounded slices.

The agent can inspect the system, challenge an approach, and help converge on a stronger strategy before production code is written. After implementation, use reviewfor the worktree or review <target-branch> for a branch. The agent produces the findings and verification; the developer chooses whether to correct, continue, or complete.

Planning sessionCredential architecture
  1. Developer

    We need organization-level API keys. I think we should add a new keys table and expose CRUD endpoints.

  2. Coding agent

    Personal tokens already use a shared secret model, encrypted storage, scoped permissions, and revocation events. A parallel table would duplicate three contracts.

  3. Developer

    Organization keys need independent rotation and must never inherit a user’s access after that user leaves.

Agreed plan

Extend the credential boundary, make organization ownership explicit, preserve one rotation flow, and verify revocation and role changes.

  1. STEP 01

    Plan

    Establish the intended final state.

  2. STEP 02

    Challenge

    Attack material assumptions before approval.

  3. STEP 03

    Breakdown

    Create coherent slices only when useful.

  4. STEP 04

    Execute

    Implement only the authorized scope.

  5. STEP 05

    Review

    Build the evidence for a developer decision.

Review outcomes

Correct
Resolve a defect or weak proof, then review the new state.
Continue
Authorize the next bounded milestone.
Complete
Accept the requested engineering outcome.

04 / Mature the project

Clear systems earn wider delegation.

Demonstrate the path, codify what repeats, delegate as the environment becomes dependable, and let stronger evidence replace routine code inspection as the corrective layer matures.

repository-maturity.systemrepeat continuously
  1. STEP 01

    Demonstrate

    Work closely, make decisions visible, and correct what does not fit.

  2. STEP 02

    Codify

    Turn recurring decisions into durable project guidance and checks.

  3. STEP 03

    Delegate

    Grant broader tasks as the surrounding system becomes dependable.

  4. STEP 04

    Verify

    Let the agent operate the evidence while the developer governs the proving system and acceptance.

What the project codifies

  • Instructions
  • Architecture
  • Tests
  • Schemas
  • Documentation
  • Automation

What ambiguity produces

  • Missed contracts
  • Duplicate mechanisms
  • Inconsistent architecture
  • Adjacent work
  • Unclear stopping points
  • Misplaced solutions

How acceptance matures

Code inspection becomes a response to risk, not a permanent ritual.

The agent carries the verification workload. The developer builds the system that makes the evidence trustworthy and keeps the decision.

  1. LEVEL 01

    Inspect directly

    The developer reads the code and the evidence while the verification system is still young.

  2. LEVEL 02

    Sample and challenge

    The developer examines all material evidence and samples the riskiest implementation paths.

  3. LEVEL 03

    Audit on signal

    Weak evidence, novelty, or material risk triggers code inspection instead of routine habit.

  4. LEVEL 04

    Lead with evidence

    Independent verification and system behavior support acceptance while code remains auditable.

05 / Bound the authority

Wide context. Narrow authority.

Inspect enough surrounding code to understand the complete affected path. Change only what the approved task requires, then use evidence to decide whether the result is acceptable.

scope-mapinspect widely, edit narrowly
Inspect to understand Authorized to edit
  • src/: inspect only
  • auth/: inspect only
  • session.service.ts: inspect only
  • permissions.ts: inspect only
  • api-keys/: authorized to edit
  • api-keys.service.ts: authorized to edit
  • api-keys.service.test-integration.ts: authorized to edit
  • organizations/: inspect only
  • organization.model.ts: inspect only
  • shared/crypto/: inspect only

A dependency is not automatically a deliverable. Capability still requires a reliable process.

06 / Use the leverage

The first benefit is speed. The lasting benefit should be better software.

Manual coding skills remain essential. Agentic Coding moves more developer attention from typing and routine inspection toward judgment, system design, independent test oracles, and correction.

Explore more

Inspect unfamiliar systems and compare more credible alternatives.

Attempt more

Make deeper planning, tests, and documentation economically practical.

Correct more

Repeat agent review and harden the evidence without treating the first output as final.

Judge more

Spend developer attention on tradeoffs, direction, and system quality.

The agent provides capability. The engineering process provides reliability.

07 / Applied in practice

Built through real project work.

Agentic Coding was shaped while building moldea, where project context, agent instructions, deterministic validation, adversarial tests, agent evidence, and developer judgment have to operate as one coherent system.

field-application/01moldea.ai

A Git-native platform for structuring project context, building complete agent instructions, and keeping the resulting system aligned with code.

Explore moldea
  1. 01

    Context in Git

    Project context, decisions, instructions, and relationships live beside the code they guide.

  2. 02

    Instructions as production assets

    Reusable instruction systems are structured, versioned, and kept visible to the team.

  3. 03

    Deterministic verification

    Repository tooling, adversarial tests, and reproducible agent evidence make behavioral alignment inspectable instead of assumed.

08 / Put it into practice

Give the work a stronger operating system.

Establish the foundation, refine what the repository already knows, and practice the workflow through concrete conversations.

Start with the foundation

Adopt a neutral, production-minded AGENTS.md in a new repository.

Open foundation

Refine existing instructions

Preserve project knowledge while strengthening the engineering process.

Open prompt

Practice the workflow

Practice planning, challenge, bounded execution, evidence, correction, and governed publication.

Open cookbook

Host-agnostic

Use the coding agent already in your repository.

The prompt is portable. The engineering values matter more than the host.

  • Codex by OpenAI
  • Claude Code by Anthropic
  • Cursor by Anysphere
  • OpenCode by Anomaly
  • GitHub Copilot by GitHub
  • Cline by Cline