AI-Assisted Development

Use AI while keeping human responsibility for the result.

Create an AI can / I must checklist.

Give each part of the AI ecosystem its correct name.

Label a simple ecosystem diagram.

See the browser, frontend, backend, database, and hosting together.

Draw one request-and-response flow.

Know the job of the editor, terminal, browser, DevTools, GitHub, and preview.

Open each tool and identify what evidence it provides.

Read src, public, package.json, README, and configuration without panic.

Create a labelled repository map.

Ask AI to inspect and explain without changing files.

Check an AI-generated codebase map against the real repository.

Make one intentional change with a clear boundary.

Change one card's text and colour only.

Prove generated code runs and builds.

Open the local page and complete a successful build.

Describe what changed and why in plain language.

Write a changed-file summary without AI jargon.

Use evidence and a small diff to repair a deliberate defect.

Return a working page plus a verification checklist.

Describe the outcome a user should receive.

Rewrite five weak prompts as observable outcomes.

Give the model the files and facts needed for this task.

Assemble a small context packet.

Protect unrelated behaviour from accidental changes.

Write must change and must not change lists.

Define completion with checks instead of feelings.

Turn a feature idea into five pass-or-fail checks.

Make desired and undesired outcomes concrete.

Pair one reference with one anti-reference.

Review approach, files, risks, and checks before code changes.

Correct one flawed implementation plan.

Move from idea to feature to small verifiable task.

Create an epic, feature, and task board.

Store repeatable project rules close to the code.

Write a beginner-readable instruction file.

Continue long work without losing decisions or current state.

Write a compact session handoff.

Require sources and make uncertainty visible.

Verify one package or API against its official documentation.

Compare like with like when discussing AI.

Classify a set of product and model cards.

Understand what fits in a model request and what may be stale.

Complete a context-budget worksheet.

Match model categories to the work they are designed for.

Complete a task-to-model-type matching game.

Choose using multiple project constraints.

Build a weighted model-selection scorecard.

Understand representative OpenAI, Anthropic, Google, Meta, xAI, Microsoft, and Amazon families.

Compare official catalogs for one real task.

Understand representative DeepSeek, Qwen, Kimi, GLM, MiniMax, ERNIE, and Hunyuan families.

Map each family to documented strengths and access methods.

Understand Sarvam, Krutrim, AI4Bharat, and BharatGen use cases.

Create an India-focused language, speech, or document use-case map.

Understand Mistral, Falcon, Llama, Gemma, and the open model ecosystem.

Compare hosted and self-hosted options.

Balance privacy, residency, hardware, licensing, and maintenance.

Write a deployment decision record.

Evaluate models on your own tasks and track their lifecycle.

Run ten cases and create a dated model registry.

Start from a person's need rather than a list of features.

Write a one-paragraph problem statement.

Describe useful behaviour from the user's point of view.

Write five testable user stories.

Choose the smallest version that proves value.

Create a now, later, and never board.

Plan happy, empty, failure, and recovery states.

Draw four versions of one important flow.

Name the information the product must store and relate.

Sketch a small entity relationship map.

Select technology for team skill, product needs, cost, and maintenance.

Write a short architecture decision record.

Agree on inputs, outputs, errors, and ownership before implementation.

Write two example request and response contracts.

Turn requirements into evidence the build must produce.

Create a feature verification matrix.

Surface important non-functional risks before code exists.

Create a small pre-build risk register.

Give the agent an ordered path and clear points to pause.

Create a milestone plan with approval gates.

Understand how an agent uses a model and tools over multiple steps.

Draw the loop around one coding task.

Protect changes that already belong to someone else.

Produce a clean pre-change report.

Separate experiments from the stable branch.

Create a focused feature branch.

Check files, architecture, risks, and verification before approval.

Find and correct three assumptions in a sample plan.

Make changes that a beginner can inspect and reverse.

Reduce a mixed diff to one feature.

Decide what an agent may run, must ask about, or may never run.

Create an allow, ask, and deny command policy.

Review behaviour, data flow, dependencies, and unexpected files.

Annotate one AI-generated diff.

Collect independent evidence that the change is healthy.

Produce a short verification report.

Package work so another person can understand and review it.

Create a focused commit and beginner-friendly pull request.

Undo a bad change without destroying unrelated work.

Revert a demo commit and write a recovery note.

Build with meaningful regions and elements.

Create an accessible landing-page skeleton.

Turn a design direction into consistent rules.

Create a small style-token sheet.

Recognize reusable interface pieces and their data.

Build one reusable lesson card.

Make one interface work on phone, tablet, and desktop.

Verify three useful viewport sizes.

Include accessibility in the definition of done.

Complete a manual accessibility checklist.

Help users enter valid data and recover from errors.

Build a usable signup form with clear messages.

Design the full life of a feature, not just ideal data.

Create a complete state gallery.

Compare reference, current output, and intended correction visibly.

Create a before, reference, and after review.

Keep a premium interface fast and stable.

Optimise a page and record before-and-after evidence.

Combine clarity, responsiveness, accessibility, and restrained polish.

Ship and verify a complete learning page.

Trace a browser request into server logic and back.

Draw and inspect one API request.

Create predictable validated endpoints.

Build a small endpoint with one fixed response shape.

Model stored information without one giant table.

Sketch a small relational schema.

Make database changes repeatable across machines and deployments.

Create and rehearse one migration.

Create, read, update, and delete only the right user's records.

Build a personal notes feature.

Separate proving identity from permission to act.

Protect a server-side action after login.

Enforce ownership close to the data and at sensitive actions.

Write policies for users to access only their records.

Know which values may reach the browser.

Create a correct environment-variable map.

Verify external events and keep integrations idempotent.

Validate a signed mock webhook.

Make important operations safe under failure and repetition.

Design a resilient API operation.

Translate the error, location, and context into plain language.

Explain one stack trace before changing code.

Create exact steps that make a bug appear.

Write a minimal reproduction checklist.

Collect browser-side evidence instead of asking AI to guess.

Capture and explain one failed request.

Follow a failure through useful server frames.

Trace a sample error to its root cause.

Run small experiments that can prove an idea wrong.

Keep a short hypothesis and result log.

Test observable behaviour around focused functions.

Write edge-case tests for one utility.

Verify important parts work together.

Test one API and database flow.

Test a real user journey and important accessible behaviour.

Automate one browser journey and manually verify keyboard use.

Run checks automatically for every proposed change.

Create or inspect a GitHub Actions quality check.

Make a fix fail before it passes and challenge the happy path.

Add a failing-then-passing regression test.

Name valuable assets, likely attackers, entry points, and impact.

Create a compact threat map.

Keep credentials out of code and respond correctly to leaks.

Remove and rotate a deliberately leaked demo key.

Review the code your project imports and its origin.

Produce a dependency review report.

Reject unexpected data at a trusted server boundary.

Add schema validation to one endpoint.

Render user and AI output without turning it into executable page code.

Repair an unsafe rendering example.

Check permission for the exact resource and action.

Attempt and block cross-user record access.

Understand how a signed-in state is protected and ended.

Complete a secure-session checklist.

Restrict what the server accepts, fetches, and stores.

Design a limited upload flow.

Prevent unlimited public use of costly actions.

Define per-user limits and a spend alert.

Collect useful evidence without storing secrets or unnecessary personal data.

Redact logs and rehearse a small restore.

Understand each layer in an agent system.

Create a correct architecture diagram.

Evaluate a connector before installing or authorizing it.

Complete an MCP trust checklist.

Give tools only the exact access and time they need.

Design a read-only scoped integration.

Run untrusted or experimental work away from personal and production systems.

Map an isolated test environment.

Recognize malicious instructions in user input and retrieved content.

Investigate a malicious webpage simulation.

Treat every model response as untrusted data.

Validate and sanitize structured model output.

Limit actions, time, turns, money, and reachable systems.

Create an autonomy budget.

Require exact-target review before email, delete, payment, or publish actions.

Design an approval gate.

Separate project data from instructions embedded inside that data.

Resolve an instruction-conflict exercise.

Observe agent actions and stop them safely.

Create a red-team report and emergency stop plan.

Call a model without exposing the secret to the browser.

Build a small protected API route.

Keep authority and untrusted content visibly separated.

Create a role-separated prompt structure.

Request predictable data and still validate it in your application.

Parse a typed JSON result.

Let a model choose a tool while your code controls execution.

Build a safe calculator-style tool.

Keep long model calls responsive and bounded.

Create a stream with cancel and failure states.

Ground an answer in selected sources and expose those sources.

Build a small cited document assistant.

Store only useful context with user control.

Design memory and delete settings.

Combine several safety controls and a human path.

Draw an input-and-output safety pipeline.

Measure model behaviour on a repeatable set of cases.

Create a twenty-case feature evaluation.

Control quality, latency, availability, and cost over time.

Design a cost-aware model router.

Give each environment a clear job and risk level.

Create an environment map.

Use separate credentials and settings across environments.

Build a development, preview, and production variable matrix.

Share a realistic build before production promotion.

Publish and inspect a preview URL.

Require lint, test, and build checks before deployment.

Create a release gate checklist.

Prepare for code and data changes to fail.

Rehearse a restore and rollback.

Observe how the production system behaves for users and the business.

Create a small monitoring dashboard plan.

Collect release evidence across devices and user needs.

Complete a release evidence pack.

Respond to failures and changing dependencies after launch.

Run a simulated incident and model migration.

Combine requirements, architecture, threats, tests, and rollback before the final build.

Produce an approved capstone plan.

Ship a product with evidence, limits, and honest next steps.

Publish the app, repository, verification report, and postmortem.