
How do you write code with Super Intelligence without turning software development into blind copy-and-paste? You use SI inside an engineering workflow: define the specification, inspect the existing system, plan the smallest change, generate or edit bounded code, run tests, review the diff, verify security and behaviour, deploy carefully and preserve enough documentation that another developer can continue.
SI can generate code quickly, but production software is not judged by how fast a code block appears. It is judged by whether the implementation matches the specification, works in the actual environment, handles failures, preserves existing behaviour, respects permissions and remains maintainable after the original conversation ends.
This eduKateSG guide explains how to write code with SI from specification to production review. It follows How to Learn Coding With Super Intelligence in Stage 6 of the How to Learn Super Intelligence Quickly curriculum.
Terminology: SI is our editorial term for practical contemporary AI learning. Writing code with SI means using intelligent assistance inside a controlled software-engineering process, not treating generated code as automatically correct, secure or deployable.
The First Principle: Specification Before Generation
Before asking SI to write code, state what the code must do, what inputs it receives, what outputs it returns, what errors are possible and which behaviour must remain unchanged.
A vague request such as “build authentication” opens a huge design space. A bounded request such as “add passwordless email login to this existing application using the current authentication provider, preserving the existing session interface and tests” is far easier to review.
The specification is the standard against which generated code is judged.
Step 1 — Inspect the Existing Codebase
When changing an existing project, read the relevant files before generating a patch. Identify entry points, interfaces, tests, configuration and ownership boundaries.
Ask SI to map the codebase if helpful, but verify paths and behaviour in the repository.
A generated architecture based on assumptions about files that do not exist is not useful.
Step 2 — Define the Smallest Change
Large generated rewrites create unnecessary risk. Define the smallest change capable of satisfying the requirement.
Examples: add one validation rule, expose one endpoint, fix one parsing bug, create one component or extend one schema.
Small changes produce smaller diffs, easier tests and simpler rollback.
Step 3 — Write Acceptance Tests or Cases
Before implementation, write examples of expected behaviour. Include normal, boundary and failure cases.
For a parser, include valid input, malformed input and missing input. For an API, include authorised and unauthorised requests. For a UI component, include loading, success and error states.
Tests make the prompt and code review more objective.
Step 4 — Give SI the Minimum Complete Context
Provide the relevant interface, nearby code, specification and constraints. Do not paste an entire repository unless necessary.
Include environment details when they change behaviour: language, framework, data shape or existing API contract.
Good context reduces hallucinated modules and invented interfaces.
Step 5 — Ask for a Plan Before a Large Patch
For nontrivial changes, ask SI to explain which files or functions should change and why. Review the plan before code generation.
A good plan identifies dependencies, tests and migration risk.
Reject plans that introduce unnecessary architecture or ignore existing conventions.
Step 6 — Generate a Bounded Patch
Ask for only the relevant function, component or diff rather than an entire file when practical.
Preserve public interfaces and unrelated code unless the specification requires change.
Bounded generation makes review faster and reduces accidental regression.
Step 7 — Read Every Changed Line
Generated code should be reviewed like code from a new contributor. Understand what changed and why.
Look for invented APIs, hidden side effects, changed defaults, unnecessary dependencies, duplicated logic and misleading comments.
If you cannot explain a changed line, investigate before merging it.
Step 8 — Run the Tests
Execute the relevant test suite in the actual environment. A model saying “this should work” is not evidence.
If tests fail, preserve the failure output and diagnose before requesting another patch.
Add regression tests for important bugs.
Step 9 — Run Static and Type Checks
Where the project uses linters, formatters, type checkers or static analysis, run them after generated changes.
These tools catch classes of error that natural-language review may miss.
Do not change project standards merely to silence warnings unless the standard itself is wrong.
Step 10 — Check Runtime Behaviour
Tests may not cover every integration state. Run the feature manually or through representative integration tests.
Check logs, network requests, database changes and user-visible states as appropriate.
Runtime evidence closes the gap between local code and real behaviour.
Step 11 — Check Error Handling
Ask what happens when inputs are invalid, dependencies fail or permissions are missing.
Generated code often focuses on the happy path. Production code needs understandable failure states.
Do not hide errors with broad catch blocks that make debugging harder.
Step 12 — Check Security Boundaries
Inspect authentication, authorisation, input validation, secrets, data exposure and external calls.
Use current official guidance and qualified review for security-sensitive changes.
SI can surface candidate risks, but security cannot be established by prompt confidence.
Step 13 — Check Data Integrity
If code writes data, confirm schema, constraints, transaction behaviour and rollback implications.
Run write operations on safe development or staging data first.
Generated SQL or migrations should be reviewed before touching important production systems.
Step 14 — Check Performance Where It Matters
Do not optimise every generated function. Measure only when the requirement or evidence shows performance matters.
For hot paths, inspect algorithmic complexity, database queries, network calls and memory use.
Measure before and after.
Step 15 — Review the Diff
A diff is one of the strongest code-review surfaces. Look for scope creep, removed checks, accidental formatting noise and unrelated changes.
Ask SI to review the diff after your own pass if useful.
The final decision should follow specification and tests, not the model’s approval language.
Step 16 — Update Documentation
When behaviour, configuration or public interfaces change, update relevant documentation in the same change.
Generated documentation should be checked against actual code.
A feature is harder to maintain when only the original conversation explains it.
Step 17 — Update Changelog or Decision Record
For significant changes, record what changed and why. Architecture decisions should preserve alternatives and trade-offs when future maintainers may revisit them.
This prevents the repository from becoming a collection of unexplained generated choices.
Step 18 — Deploy Through the Normal Pipeline
Do not bypass established CI/CD or review procedures simply because SI produced the patch quickly.
Use staging, build checks and deployment approvals appropriate to the project.
The software process remains the authority for release.
Step 19 — Verify Production
After deployment, check the live system: feature behaviour, errors, logs and relevant metrics.
A successful deployment job proves only that deployment completed.
Confirm the receiver outcome in production.
Step 20 — Preserve Rollback
Know how to return to a stable version if the change fails.
Rollback may involve code, configuration, database migration or feature flag depending on the system.
Reversibility makes SI-assisted iteration safer.
The SI Coding Change Card
- Problem.
- Specification.
- Current behaviour.
- Desired behaviour.
- Relevant files/interfaces.
- Constraints.
- Acceptance tests.
- Proposed patch.
- Security/data impact.
- Review result.
- Test result.
- Deployment state.
- Production verification.
- Rollback.
Writing New Functions With SI
Define function name, inputs, outputs, error behaviour and side effects. Prefer small, testable functions.
Ask for implementation plus tests only after the contract is clear.
Reject hidden global state or unrelated dependencies unless justified.
Writing Classes With SI
Use classes when state and behaviour belong together or the architecture requires an interface.
Avoid generated class hierarchies that add abstraction without solving a concrete problem.
Test public behaviour rather than internal implementation where practical.
Writing APIs With SI
Specify method, path, request schema, response schema, error states, authentication and authorisation.
Use current framework conventions and official docs. Validate external input on the server.
Test normal, invalid, unauthorised and unavailable-dependency cases.
Writing Database Code With SI
Define query intent, expected rows, transaction requirements and indexes where relevant.
Separate reads from writes and review destructive statements carefully.
Use development data and backups before migrations.
Writing Frontend Components With SI
Define states: default, loading, error, empty, disabled and success. Define keyboard and accessibility behaviour.
Generate markup and styling within the existing design system.
Test the component in the browser and at responsive sizes.
Writing Backend Services With SI
Define boundaries: input validation, business rule, persistence, external services and response.
Keep responsibilities small enough to test.
Avoid letting generated service layers duplicate existing domain logic.
Writing CLI Tools With SI
Specify arguments, help text, exit codes, stdout/stderr behaviour and destructive-operation confirmation.
Test invalid arguments and file paths.
Be cautious with generated commands that delete, overwrite or change permissions.
Writing Data Pipelines With SI
Define source schema, transformation, destination, error handling, idempotency and observability.
Validate data shape before transformation. Preserve raw source when appropriate for recovery.
Test partial failure and rerun behaviour.
Writing Automation Scripts With SI
Automation should begin from a stable manual process. Define exactly what may be changed and what requires confirmation.
Use dry-run or preview modes where practical.
Logs should make the action recoverable and auditable.
Writing Tests With SI
Generated tests are valuable for coverage expansion but should be reviewed against the specification.
Ask for edge cases and failure conditions, then add cases from historical bugs.
Avoid tests that simply mirror implementation details and pass even when user behaviour is wrong.
Writing Documentation With SI
Ask for documentation only after interfaces and behaviour are stable enough.
Include setup, public API, examples, failure states and maintenance notes appropriate to the project.
Run documented commands in a clean environment where feasible.
Using SI for Bug Fixes
Provide reproduction, error, relevant code and expected behaviour. Ask for the smallest likely cause before the patch.
Write a regression test, then make the minimal repair.
Avoid broad refactors mixed with bug fixes unless the architecture itself is the cause.
Using SI for Refactoring
State the refactor objective and preservation set. Tests should pass before and after.
Review whether the generated structure is genuinely simpler or merely more abstract.
Refactoring is successful when behaviour remains and maintainability improves.
Using SI for Code Review
Ask for line-specific concerns and classify by correctness, security, performance, maintainability and test gap.
Reviewers should challenge generated findings as well. A confident warning can be false or irrelevant.
Use tool output and project standards to decide.
Using SI for Architecture
Architecture prompts should include load, data, reliability, team skill, constraints and current system.
Request several architectures with trade-offs rather than one “best” answer.
Prototype high-uncertainty components before committing.
Using SI for Migrations
Migrations require source/destination schema, mapping, validation, rollback and partial-failure strategy.
Run on representative copies before live data.
Compare counts, checksums or other relevant invariants after migration.
Using SI for Dependency Upgrades
Read current release notes and migration guides. Ask SI to map affected code, but verify against official sources.
Upgrade incrementally when possible and run the full relevant test suite.
Dependency changes can affect security and runtime even when application code barely changes.
Using SI for Performance Work
Start with measurements and traces, not guesses.
Ask SI to interpret profiles or query plans and propose experiments.
Accept optimisation only when evidence shows improvement without unacceptable complexity.
Using SI for Security Review
Use SI to generate questions and candidate weaknesses, not to certify security.
Run appropriate scanners, tests and qualified reviews. Protect sensitive code and secrets according to organisational policy.
Security findings need reproduction and evidence.
Generated-Code Failure 1 — Invented API
Code calls a method that does not exist.
Repair by checking current official documentation and installed version.
Failure 2 — Hidden Scope Expansion
Patch changes unrelated files or behaviour.
Return to minimal change and preservation set.
Failure 3 — Happy-Path Only
Normal test passes; invalid or failed dependency breaks.
Add failure-state tests.
Failure 4 — Security Regression
New code bypasses validation or authorisation.
Review boundary and permission checks explicitly.
Failure 5 — Data Loss Risk
Migration or script overwrites important state.
Use backups, dry run and transaction/recovery design.
Failure 6 — Dependency Bloat
A large package is added for a tiny task.
Check standard library and existing dependencies first.
Failure 7 — Over-Abstraction
Generated code introduces layers that make the change harder to understand.
Prefer simplest design meeting current requirements.
Failure 8 — Misleading Comments
Comments describe intended behaviour that code does not implement.
Trust runtime and tests; update documentation.
Failure 9 — Test Theater
Many tests exist but do not cover user-critical behaviour.
Tie tests to specification and historical failures.
Failure 10 — Deployment Blindness
Local patch works but production configuration differs.
Use environment-aware deployment and production verification.
The Generated-Code Review Checklist
- Matches specification.
- Uses real APIs.
- Minimal scope.
- No unexplained dependencies.
- Inputs validated.
- Permissions respected.
- Errors handled.
- Data integrity preserved.
- Tests meaningful.
- Types/static checks pass.
- Diff reviewed.
- Documentation updated.
- Deployment path normal.
- Rollback understood.
Worked Example: Fix an Off-by-One Bug
Reproduce the failure with a boundary input. Add a regression test. Identify which range or index condition is wrong.
Ask SI for the smallest patch, review the diff and run all related tests.
The accepted change should be explainable without referring to the chat.
Worked Example: Add an API Endpoint
Define request and response schema, permissions and errors. Add tests before or alongside implementation.
Generate route and service changes within existing conventions. Run integration tests.
Verify production endpoint and logs after deployment.
Worked Example: Add a Form
Define fields, validation, submission endpoint, privacy and success/error states.
Generate component and backend changes separately, then test end to end.
Check actual submission destination before claiming success.
Worked Example: Database Migration
Specify old schema, new schema, mapping and invariant such as row count or unique IDs.
Test migration on a copy, verify results and rehearse rollback.
Only then schedule production migration with backups and monitoring.
Worked Example: Refactor Duplicated Logic
Identify duplicate behaviour and write tests covering both call sites.
Extract the smallest shared function, preserve interface and run tests.
Do not mix unrelated cleanup into the same change.
Worked Example: Generate a Small Feature
Requirement: add a user preference toggle. Define persistence, default, UI, API and permission.
Build one layer at a time and verify state travels correctly end to end.
Generated code is accepted only after the live behaviour matches the specification.
Code Review With Multiple SI Approaches
For higher-value changes, one system can generate and another can critique, or the same system can review in a separate pass.
Agreement is not independent evidence if both rely on the same wrong assumption. Tests and documentation remain stronger.
Use multiple perspectives to generate questions, not automatic consensus.
Code Ownership
A team should know who owns generated code after merge. “The AI wrote it” is not an ownership model.
The human or team accepting the change becomes responsible for maintenance, tests and future fixes.
Only merge code the owner is willing and able to support.
Code Provenance
For important projects, preserve commit history, issue link and specification. This makes generated changes traceable like other contributions.
Do not rely on chat transcripts as the only rationale.
A short decision note is usually more maintainable than a long conversation export.
The SI Coding Handoff
A handoff package includes specification, diff, tests, configuration changes, migration notes, known limitations, deployment state and rollback.
Another developer should be able to continue without reconstructing context from the AI session.
Portable project state protects engineering continuity.
Frequently Asked Questions
Can I let SI write most of the code?
It can generate large amounts, but review burden, tests and system understanding still matter. More generated volume can increase risk if the team cannot inspect it.
Should I accept code that passes tests?
Passing tests is necessary evidence but not sufficient. Review specification coverage, security, maintainability and integration.
Can SI review its own code?
It can provide useful critique, but external tests, tools and human review provide stronger independent evidence.
What if I do not understand the generated code?
Do not merge it until you or the responsible team can explain and support it. Reduce the task or seek expertise.
How do I keep generated code maintainable?
Prefer small changes, existing conventions, strong tests, clear interfaces and documented decisions.
What comes next?
Continue Stage 6 with debugging, understanding existing code, data analysis and spreadsheets in the complete SI learning hub.
The Code Change Lifecycle
A mature SI coding workflow treats a change as a lifecycle rather than a prompt. The lifecycle begins with issue or requirement, passes through specification, code and tests, then continues through review, integration, deployment, monitoring and maintenance.
Every stage has a different source of truth. The issue owns the user problem. The repository owns the implementation. The test suite owns known executable expectations. Production telemetry owns live behaviour.
SI can connect these layers, but should not collapse them into one generated answer.
Issue Framing
Before coding, write the problem as an issue that a developer could understand. Include current behaviour, desired behaviour, reproduction where relevant and acceptance conditions.
Avoid implementation language unless the implementation is itself required. “Users cannot recover a saved draft after refresh” is a better problem statement than “add localStorage” when several solutions are possible.
SI can help rewrite vague tickets into testable requirements.
Acceptance Criteria
Acceptance criteria translate product intent into observable behaviour. They should be specific enough to test but not so implementation-heavy that they dictate unnecessary design.
For example: “When the user refreshes after saving, the draft reappears within the same authenticated account.” Add failure cases such as expired session or corrupted draft.
The criteria become the anchor for generated code, tests and review.
Non-Functional Requirements
Software requirements include more than features. Performance, accessibility, security, reliability, compatibility and maintainability may matter.
State the relevant non-functional requirements before generation. Otherwise SI will optimise primarily for functional success.
Do not add every possible requirement to every small task. Match rigor to consequence and system context.
Existing Conventions
Repositories have naming, file layout, error handling, testing and dependency conventions. Generated code should usually fit them rather than importing a new pattern from a generic example.
Ask SI to inspect nearby examples before proposing a change. A locally consistent solution is often easier to maintain than an abstractly elegant but foreign one.
Project conventions are evidence about how the codebase is intended to work.
Repository Map
For unfamiliar projects, build a compact map: entry points, major modules, data layer, external services, tests and deployment files.
Do not map every file. Focus on paths relevant to the change.
SI can create the first map, but verify it by navigating the actual repository.
Codebase Search
Search for existing interfaces, similar features, error messages and tests before writing new code. Existing solutions often reveal the correct extension point.
This reduces duplicate utilities and inconsistent abstractions.
Use exact symbols and semantic search as complementary methods.
Dependency Analysis
Before adding code, identify what depends on the changed component and what the component depends on.
High fan-out changes deserve broader regression testing. A utility used across the application can create more risk than a local component.
Dependency analysis helps determine the right change size and review depth.
Change Surface
The change surface is the set of files, interfaces, data, tests and systems affected by the implementation.
Write it down before generation. If the patch touches far more than the predicted surface, investigate whether the plan is overbroad or the architecture contains hidden coupling.
A small change surface is easier to validate.
Patch Planning
For medium changes, create a patch plan with ordered steps and tests after each step. This reduces large all-at-once generations.
Example: add data field → migrate local schema → expose API field → render UI → add integration test.
Each step should leave the repository in a coherent state where possible.
One-Variable-at-a-Time Coding
When debugging or refactoring, avoid changing several mechanisms simultaneously. Modify the suspected cause, rerun evidence and observe.
This is especially important with SI because the system can produce sweeping rewrites easily.
Smaller experimental changes improve causal understanding of the fix.
Diff-First Collaboration
Ask SI to express changes as a conceptual diff: what lines or functions change, what remains untouched and why.
Even when the tool applies edits automatically, review the actual version-control diff afterward.
Diff-first thinking turns code generation into an inspectable proposal rather than a replacement file.
Code Generation With Explicit Invariants
List behaviours that must remain true: public API, data format, performance budget, permission checks or backward compatibility.
Include these invariants in the generation request and tests.
A patch that solves the new requirement by breaking an invariant is not successful.
Backward Compatibility
Changes to APIs, schemas or file formats may affect existing consumers. Decide whether backward compatibility is required and for how long.
When breaking change is intentional, provide migration path and version communication.
SI can help identify call sites or consumers, but search and tests should confirm them.
Feature Flags
Feature flags can separate deployment from release and make rollback easier for certain features.
Use them when operationally justified, not as permanent complexity. Define default, ownership and removal date.
Generated flag logic should be tested in both states.
Configuration Changes
Configuration can change behaviour as much as code. Treat environment variables, feature settings and deployment configuration as part of the change.
Document new required variables and safe defaults. Avoid leaking secrets into logs or repositories.
Test missing and invalid configuration states.
Schema Changes
Data schemas create durable contracts. Before changing them, inspect existing records, constraints, migrations and downstream consumers.
Prefer additive changes when practical, then migrate readers and writers deliberately.
SI can draft migration code, but test it on representative copies and preserve rollback or recovery.
Database Transactions
Multi-step writes can leave partial state if one operation fails. Understand whether the database or application needs a transaction.
Generated code may omit transaction boundaries because the happy path looks correct.
Test failure in the middle of the operation, not only success.
Idempotency
Retries can duplicate external actions unless operations are idempotent or protected by unique keys and state checks.
This matters for payments, jobs, webhook processing and automation.
Ask SI to identify which operations may repeat and how duplicate effects are prevented.
Concurrency
Concurrent requests can expose race conditions invisible in single-user tests. Shared counters, reservations, inventory and asynchronous jobs deserve special attention.
Do not assume a local test proves concurrency safety.
Use database constraints, atomic operations, locks or architecture appropriate to the system and review with expertise where necessary.
Asynchronous Work
Queues and background jobs introduce new states: queued, running, failed, retried and completed.
Generated code should define retry and dead-letter behaviour rather than hiding failures.
The user-facing system should distinguish accepted work from completed work.
External APIs
External services can time out, rate-limit, change responses or return errors. Wrap integrations with clear boundaries and validation.
Use official current documentation and test against sandbox or development environments when available.
Do not let SI invent response fields based on memory.
Retries
Retries can improve resilience but also amplify load or repeat destructive actions.
Define which failures are transient, how many retries occur and what backoff or escalation applies.
Log final failure clearly so the workflow does not claim completion.
Timeouts
External calls should not wait forever. Timeouts are part of interface contracts.
Set them according to expected service behaviour and user experience, then handle timeout states explicitly.
SI can suggest patterns, but production latency evidence should tune them.
Caching
Caching trades freshness for speed or cost. Before adding it, define what is cached, for how long and how invalidation works.
Generated caching code can create stale-data bugs if ownership and freshness are unclear.
Use caching when measurement shows benefit and the freshness envelope is acceptable.
Pagination
APIs and database queries should handle collections larger than the first page when the domain can grow.
Generated prototypes often assume small data. Test empty, one-page and multi-page cases.
Cursor or offset choices depend on data and platform constraints.
Input Validation
Validate untrusted input at the boundary. Client-side validation improves user experience but should not be the only protection for server operations.
Define types, ranges, formats and required fields. Return errors that are useful without exposing sensitive internals.
Validation rules should align with domain rules, not only syntax.
Output Encoding
When output is rendered into HTML, SQL, shell commands or other interpretable contexts, use appropriate safe libraries and encoding patterns.
Do not hand-build escaping rules from generated guesses for security-sensitive boundaries.
Framework and platform guidance should control implementation.
Authentication
Authentication establishes identity. Use established providers and libraries appropriate to the application.
Generated code should not reinvent password storage or session security casually.
Review account recovery and session lifecycle as part of the feature.
Authorisation
Authorisation determines what an authenticated identity may do. Every sensitive action should check permission on the authoritative side of the boundary.
Do not rely solely on hidden UI controls.
Test users with different roles and ownership relationships.
Secrets
API keys, passwords and signing secrets should live in protected configuration or secret stores rather than source code or prompts.
Rotate exposed secrets according to incident procedures.
SI should not receive secrets unless the workflow and product are authorised for that information.
Logging Sensitive Data
Logs can accidentally expose tokens, personal data or confidential payloads. Define what must be redacted.
Generated debugging code should be removed or hardened before production.
Observability should help diagnosis without becoming a new data leak.
Privacy in Code
Collect and retain only data needed for the product and obligations. Make deletion, retention and access paths explicit where relevant.
SI can help trace data flows, but legal and organisational requirements should be reviewed by the appropriate experts.
Privacy begins with architecture, not just policy copy.
Accessibility in Code
Accessibility requirements should be represented in component tests and review checklists where possible.
Generated UI should use semantic elements, labelled controls, keyboard behaviour and accessible error feedback.
Manual testing remains necessary for important flows.
Internationalisation
Internationalised applications separate user-visible text, locale formatting and content direction where needed.
Dates, numbers and currencies should not be assembled through assumptions about one locale.
SI can help extract strings and test variants, but actual locale data should come from proper libraries.
Time Zones
Time-zone bugs are common because local time, UTC, daylight changes and user locale can interact.
Store and convert time according to system requirements, using established date-time libraries.
Test boundary dates and multiple zones when scheduling matters.
Numerical Precision
Money, measurements and floating-point calculations may require explicit precision rules.
Do not assume ordinary floating-point arithmetic matches domain expectations.
Use appropriate numeric representations and tests for rounding.
Determinism
Some systems require repeatable outputs. If SI-generated code introduces randomness, timestamps or unordered processing, define whether determinism matters.
Tests may need seeded randomness or controlled clocks.
Make nondeterminism visible rather than treating flaky tests as noise.
Test Pyramid Thinking
Use fast unit tests for local behaviour, integration tests for boundaries and a smaller number of end-to-end tests for critical user paths.
The exact balance depends on architecture, but every layer should have a reason.
SI can generate tests at all layers; maintainers decide which provide useful evidence.
Contract Tests
When services depend on interfaces, contract tests can confirm that request and response expectations remain compatible.
They are especially useful when teams or services deploy independently.
Generated contracts should reflect actual consumer needs rather than theoretical completeness.
Property-Based Testing
For suitable functions, properties can test many generated inputs: sorting preserves elements, parsing then serialising may preserve meaning, totals remain nonnegative.
Property-based tests complement example tests by exploring broader input spaces.
Choose properties from domain invariants, not from the implementation itself.
Fuzz and Boundary Testing
Unexpected or malformed input can reveal crashes and unsafe assumptions.
Use appropriate tools and environments to test boundaries without risking production systems.
SI can suggest categories, while automated testing tools provide the actual input volume.
Test Data
Use representative synthetic or appropriately authorised data. Avoid copying sensitive production records into prompts or local fixtures without necessity.
Include edge shapes: missing fields, long values, unicode, duplicate records and unusual dates where relevant.
Test data quality shapes the failures you can discover.
CI Pipelines
Continuous integration can run tests, type checks, builds and static analysis automatically on changes.
Keep CI failures visible and actionable. Do not disable checks simply to merge generated code.
SI can explain a failure, but the pipeline state remains evidence.
Pull Requests
A good pull request states problem, approach, tests, screenshots or evidence, risk and rollout where needed.
Generated descriptions should be checked against the actual diff.
Reviewers need enough context to evaluate without reading the entire AI conversation.
Code Review Boundaries
Reviewers should know which parts are generated only if that information matters to policy; regardless of origin, the accepted code must meet the same engineering standard.
Large generated diffs should be split if they are impossible to inspect confidently.
Reviewability is a design constraint on the patch itself.
Merge Discipline
Merge only after required checks and review pass. Avoid stacking uncertain generated changes until the branch becomes hard to reason about.
If several changes depend on one another, keep commits meaningful enough for debugging and rollback.
Repository history is part of maintainability.
Release Planning
For significant features, define release sequence, migrations, flags, monitoring and communication.
The plan should identify irreversible steps and rollback limits.
SI can draft the release checklist from project context, while operators confirm production specifics.
Canary and Staged Rollouts
Some systems benefit from gradual release to a small percentage of users or environments.
Staged rollout reduces blast radius and creates real evidence before full deployment.
Use only when the infrastructure and product justify the added complexity.
Monitoring After Release
Define what metrics or logs would show success and what would signal regression.
Monitor user outcome as well as technical health. A feature can be error-free but unusable.
Set ownership for alerts so monitoring produces action rather than noise.
Incident Response
When a generated change contributes to an incident, treat it like any engineering incident: stabilise, collect evidence, identify first divergence, recover and document prevention.
Do not blame the model as a substitute for examining the acceptance and review process.
The team owning the code also owns the recovery.
Post-Release Review
Compare predicted outcome, actual metrics, bugs and maintenance cost. Did the SI workflow reduce time? Did review burden rise?
Capture reusable lessons and update prompts, tests or engineering standards where the failure was systematic.
The code-writing workflow should improve through evidence.
Code Generation Policies
Teams may define where SI-generated code is permitted, what data can be shared, required review, licence checks and security gates.
Policies should distinguish low-risk prototypes from high-consequence production systems.
The goal is controlled leverage, not blanket prohibition or blind adoption.
Licence and Dependency Review
Generated code may resemble common patterns or introduce third-party dependencies. Review licences and provenance where project policy requires it.
Use dependencies from trusted sources and maintain an inventory for production applications.
Legal or compliance questions should be routed to the appropriate experts.
Model Context and Repository Privacy
Before supplying proprietary code, confirm that the selected tool and organisational policy permit it.
Minimise shared context to the relevant files and redact secrets.
Engineering productivity should not create uncontrolled information exposure.
Multi-Agent Coding
Multiple coding agents can work on separate components, tests or reviews, but they require shared specification and repository state.
Parallel agents can create merge conflicts or inconsistent assumptions if boundaries are weak.
Use explicit ownership, interfaces and integration tests before scaling agent count.
Agentic Code Modification
An agent that can edit files, run tests and commit changes should still operate inside a bounded task and permission set.
Require evidence of tests and inspect diffs before consequential merges or deployments.
Autonomy increases the need for observability and rollback.
Codegen Benchmarks
Evaluate SI coding on representative tasks from your environment rather than public demos alone.
Measure acceptance rate, review time, defect rate and total time to correct completion.
The best model or workflow is the one that improves your engineering system, not merely produces the most code.
Human Skills That Become More Valuable
As code generation gets cheaper, specification, review, debugging, system design, security, data modelling and product judgment become more important.
Developers need enough code literacy to detect plausible but wrong implementations.
SI changes the cost of typing; it does not remove the need to understand software systems.
When Not to Use SI for Code
Avoid or limit SI when code is highly sensitive and the tool is not authorised, when the team cannot review the output, or when a regulated or safety-critical context requires stricter processes.
Sometimes reading official documentation or writing a small deterministic change directly is faster and safer.
Tool choice should follow task risk and evidence needs.
A Production Coding Audit
- Problem is defined.
- Acceptance criteria exist.
- Relevant code inspected.
- Change surface bounded.
- Tests cover normal and failure cases.
- Generated diff understood.
- Static/type checks pass.
- Security boundaries reviewed.
- Data/migrations reviewed.
- Documentation updated.
- CI passes.
- Deployment plan exists.
- Rollback understood.
- Production verified.
- Owner accepts maintenance responsibility.
A Final Code-Writing Portability Test
Take the accepted change and hand it to another competent developer with only the repository, issue, tests and decision notes. They should be able to understand why the code exists and how to modify it.
If essential reasoning remains only in the SI conversation, move it into code comments, tests, documentation or a short architecture decision as appropriate.
This portability test is the final protection against code that works today but cannot be maintained tomorrow.
A Final SI Coding Governance Gate
Before merging an important SI-assisted change, confirm that the specification, evidence, security review, tests, ownership and deployment process meet the same standard you would require from human-written code.
Then verify the live outcome and preserve the lesson from the change. The strongest coding workflow uses SI to accelerate engineering without lowering the floor that makes software trustworthy.
Generated code is a proposal. Accepted, tested, deployed and maintained code is engineering.
The Final Code Acceptance Record
For significant SI-assisted changes, keep a concise acceptance record containing the requirement, final diff or commit, tests run, security or data review, deployment state and production verification. This record should be far shorter than the conversation but strong enough to explain why the change was accepted.
When a later bug appears, the acceptance record helps distinguish whether the original specification was incomplete, the implementation was wrong or the environment changed. It becomes part of the repository’s operational memory.
The strongest SI coding workflow therefore closes every consequential change with evidence and ownership. Code is not complete because a model generated it or because it compiled once. It is complete when the responsible team understands it, the relevant checks pass, the live system behaves correctly and a future maintainer can recover the reasoning from maintained project records.
Final Production Maintainability Check
After the change has been live long enough to observe, ask whether another developer can diagnose and modify it using the repository, tests, logs and documentation alone. If future maintenance still depends on the original SI conversation, move the missing rationale into durable engineering records.
This last check keeps SI-generated acceleration compatible with long software lifecycles. The codebase should become easier to understand after an accepted change, not more dependent on a transient assistant session.
Code Quality Regression Benchmark
Keep representative changes and historical failures as regression benchmarks. After adopting a new SI coding workflow, compare accepted code on scope, test quality, defect rate, review time and maintainability rather than measuring only generation speed.
If throughput rises while reviewers understand less, patches grow larger or regressions increase, the workflow has moved in the wrong direction. Use the benchmark to preserve the engineering floor while experimenting with faster tools.
Final Engineering Floor
Every future SI-assisted change should continue to meet the same specification, testing, review, security, deployment and ownership floor, even when newer models make code generation substantially faster.
Writing Code With SI Is Still Software Engineering
The model can accelerate implementation, but the engineering process supplies trust: specification, tests, review, security, deployment and ownership.
Use SI to reduce typing and widen analysis while keeping executable evidence and responsible human acceptance at the centre of the workflow.
