Explore more
Inspect unfamiliar systems and compare more credible alternatives.
Professional software development after manual coding
A disciplined way to build softwarewith coding agents.
Use coding agents across planning, implementation, and agent-operated evidence. Developers supervise the proof, direct deeper audits when risk demands them, and own final acceptance.
- 01Developer
Intent
Add organization-owned API-key rotation without creating a parallel credential system.
- 02Together
Plan
Extend the existing credential boundary and preserve one rotation flow.
- 03Agent
Execute
Implement the approved slice with ownership checks and focused tests.
- 04Agent-operated
Evidence
The agent builds and attacks the evidence. The developer governs the proving system and decides.
Agent-operated. Developer-governed. Acceptance remains the developer's responsibility.
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
| Dimension | Manual coding | Agentic Coding | Vibe coding |
|---|---|---|---|
| Planning | Developer-led and developer-executed | Developer and agent investigate together | Often compressed into the initial request |
| Architecture | Designed directly by the developer | Proposed, challenged, and approved collaboratively | Frequently delegated with the implementation |
| Implementation | Mostly written by the developer | Broadly delegable within approved boundaries | Broadly delegated toward a visible result |
| Context | Held and explored by the developer | Inspected widely enough to understand the affected path | Often limited to the prompt and immediate files |
| Verification | Developer runs and interprets checks | Agent operates most checks; developer challenges the evidence | Visible behavior may be the primary signal |
| Review | Developer reviews their own or others’ work | Agent reviews fully; developer audits by risk and decides | May stop when the result appears to work |
| Responsibility | Developer | Developer | Still the developer, even when inspection is light |
| Primary goal | Direct control through direct execution | More leverage without surrendering discipline | Reach 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, 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 / Collaborate on the work
Plan together. 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 <branch-name> for a branch. The agent produces the findings and verification; the developer challenges the evidence and decides.
Planning sessionCredential architecture
- Developer
We need organization-level API keys. I think we should add a new keys table and expose CRUD endpoints.
- Coding agent
Personal tokens already use a shared secret model, encrypted storage, scoped permissions, and revocation events. A parallel table would duplicate three contracts.
- 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.
- STEP 01
Plan
Establish the intended final state.
- STEP 02
Breakdown
Create coherent reviewable slices.
- STEP 03
Execute
Implement only the authorized scope.
- STEP 04
Review
Agent builds the evidence; developer judges whether it is enough.
03 / 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.
- STEP 01
Demonstrate
Work closely, make decisions visible, and correct what does not fit.
- STEP 02
Codify
Turn recurring decisions into durable project guidance and checks.
- STEP 03
Delegate
Grant broader tasks as the surrounding system becomes dependable.
- 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.
- LEVEL 01
Inspect directly
The developer reads the code and the evidence while the verification system is still young.
- LEVEL 02
Sample and challenge
The developer examines all material evidence and samples the riskiest implementation paths.
- LEVEL 03
Audit on signal
Weak evidence, novelty, or material risk triggers code inspection instead of routine habit.
- LEVEL 04
Lead with evidence
Independent verification and system behavior support acceptance while code remains auditable.
04 / 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.
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.
05 / 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.
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.
06 / 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.
- 01
Context in Git
Project context, decisions, instructions, and relationships live beside the code they guide.
- 02
Instructions as production assets
Reusable instruction systems are structured, versioned, and kept visible to the team.
- 03
Deterministic verification
Repository tooling, adversarial tests, and reproducible agent evidence make behavioral alignment inspectable instead of assumed.
07 / 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 foundationRefine existing instructions
Preserve project knowledge while strengthening the engineering process.
Open promptPractice the workflow
Practice planning, bounded execution, agent-operated evidence, and developer judgment.
Open cookbookHost-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