AI-Driven Full-Stack Engineering conversion Course_

Define which decisions remain human-owned and which implementation tasks may be delegated to a coding agent for a given feature.

Create repository-level agent instructions that specify architecture rules, coding conventions, commands, and quality gates.

Write a bounded implementation brief with acceptance criteria, constraints, permitted files, and explicit non-goals.

Prompt a coding agent to produce a file-level implementation plan that identifies tests, risks, and unresolved decisions before editing code.

Execute a planned change through a coding agent in small, reviewable increments, requiring verification evidence after each increment.

Verify an agent-completed task against its acceptance criteria using diff inspection, automated checks, and targeted manual probes.

Configure a strict TypeScript backend that validates environment configuration at startup.

Implement an HTTP endpoint with schema-validated parameters, request data, and response data.

Map domain and infrastructure failures to a consistent HTTP error format without leaking sensitive details.

Separate transport, application, domain, and persistence responsibilities for one backend use case.

Generate an OpenAPI description and a typed client from the backend API contracts.

Secure one resource endpoint by validating a bearer token, deriving the authenticated principal, and enforcing resource ownership in the application service.

Design a normalized PostgreSQL schema for users, tasks, agent runs, run events, and tool approvals, including keys and constraints.

Create a reversible database migration and deterministic development seed data for the project schema.

Implement a parameterized repository query that maps database records to domain types.

Use a database transaction to preserve consistency across an agent-run state transition and its associated event record.

Make a run-creation command idempotent by storing and checking an idempotency key.

Claim and process queued agent runs in a background worker with concurrency safety, bounded retries, and explicit terminal failure states.

Implement an authorized Server-Sent Events endpoint that streams persisted run events with event identifiers that support resuming after reconnection.

Represent an agent run as an explicit state machine with valid transitions and terminal states.

Wrap a model API behind a TypeScript adapter that validates structured model output against a runtime schema.

Define a typed tool contract containing input and output schemas, required permissions, and failure behavior.

Implement a tool registry and dispatcher that rejects unknown tools and invalid arguments.

Implement an agent loop with limits on steps, elapsed time, token usage, and tool failures.

Persist model requests, decisions, tool calls, results, and state transitions as an auditable run trace.

Transform repository documentation into traceable, size-bounded chunks with source metadata.

Store document embeddings and retrieve relevant chunks for a development task using a similarity query.

Assemble a token-bounded model context that preserves source attribution and requires cited answers.

Enforce least-privilege authorization for every tool invocation in the dispatcher.

Harden retrieved-content and tool-output handling against prompt injection by marking them as untrusted and keeping authorization outside model control.

Implement a durable approval workflow that pauses an agent run and binds each approval decision to the exact tool, arguments, scope, and expiration before resuming.

Partition a Vue application into routes, page components, feature components, and reusable UI components around the core user journey.

Call the backend through the generated TypeScript client and expose server state through a focused Vue composable.

Build an accessible task-submission form with client-side validation and backend error presentation.

Render explicit loading, empty, failure, cancellation, and retry states for asynchronous agent runs.

Consume streamed run events with reconnect and resume behavior, and render a chronological timeline of model decisions and tool activity.

Build an approval interface that displays the requested action, arguments, risk, and scope before accepting or rejecting a tool call.

Classify project failure modes as deterministic or stochastic and assign an appropriate automated verification method to each.

Write unit tests for agent state transitions, budget enforcement, and tool-argument validation.

Write an integration test that exercises a backend use case against a real PostgreSQL test database.

Write a deterministic end-to-end test for task submission, agent execution, approval, and result display by mocking model responses while exercising actual application state transitions.

Create a versioned evaluation dataset containing representative tasks, explicit scoring criteria, edge cases, and adversarial inputs.

Run two model or prompt configurations against the evaluation dataset and compare quality, latency, and cost before selecting one.

Create production-oriented multi-stage container builds for the TypeScript backend and Vue frontend.

Configure continuous integration to run formatting, linting, type checking, and deterministic tests on pull requests, with a budgeted agent-evaluation gate for release candidates.

Deploy the frontend, API, and worker from version-controlled configuration while supplying secrets externally and assigning least-privileged service identities.

Execute database migrations as a controlled release step with a documented rollback condition.

Propagate a correlation identifier through the API, worker, model adapter, and tool dispatcher using structured logs and traces.

Provision dashboard visualizations and alert rules as code for request failures, agent latency, queue depth, token usage, and estimated model cost.

Threat-model the deployed system across user input, retrieved content, model output, tool execution, credentials, and stored traces.

Apply rate limits, concurrency controls, and queue backpressure to protect the service and its external dependencies.

Define timeout, retry, circuit-breaker, cancellation, and fallback policies for each external dependency.

Diagnose a seeded production failure, using a coding agent as an evidence-constrained assistant, by correlating logs, traces, metrics, queue state, and recent deployment changes.

Conduct a release-level review of an agent-generated pull request for architectural boundary violations, inadequate tests, security defects, and migration risk.

Make a release decision using architecture trade-offs, test and evaluation evidence, service objectives, known risks, and a rollback plan.