androidengineers.Book a session LEARN WITH A CLEAR DIRECTION
Learn what agents are, master Python and AI foundations, then build reliable tool-using systems with memory, planning, approvals, evaluation, and operations.
Start with what agents are and how they differ from chatbots and fixed workflows. Learn Python and AI application foundations inside this roadmap before building tool loops, memory, durable state, planning, MCP integrations, and human oversight. Develop one support-agent project through increasingly capable stages and finish with evaluation, operations, and a portfolio review.
Self-paced. Start with the role introduction and follow the full foundation sequence. If you already know a topic, use its exercise and exit check to demonstrate the skill before moving ahead. There are no weekly deadlines.
YOUR PROGRESSION
Complete the labs and keep the evidence. Use each checkpoint to decide whether to move forward or revisit a skill.
Module 1
Explain the vocabulary, responsibilities, and learning journey.
Evidence: Role map, first-project description, and a personal starting-point assessment.
Go to this stage’s final module →Modules 2–15
Write, test, and organize a complete Python application.
Evidence: 42 Python lessons and exercises, ending in a document-processing CLI and an exit review.
Go to this stage’s final module →Modules 16–19
Understand systems, web requests, data, quantitative reasoning, and learning from examples.
Evidence: Environment exercises, request-flow diagram, metric calculations, and leakage-aware dataset split.
Go to this stage’s final module →Modules 20–31
Build and evaluate the software foundation that your specialization relies on.
Evidence: Model-backed API, retrieval pipeline, evaluation suite, security checks, and deployment exercise.
Go to this stage’s final module →Modules 32–43
Engineer reliable agent systems.
Evidence: Tool runtime, durable state, approvals, and trajectory evaluation.
Go to this stage’s final module →Module 44
Demonstrate an end-to-end project and defend its design.
Evidence: Working project, reproducible checks, failure demonstration, and reviewed portfolio.
Go to this stage’s final module →THE CURRICULUM
118 lessons across 44 modules. Open a module to explore its lessons and practical work.
Understand the role, vocabulary, responsibilities, and learning sequence before starting technical work.
Ready to move on when: Explain the role and identify the first project and skills you will build.
Learn and practise what python is and how a program runs, editor, terminal, virtual environments, and packages, expressions, names, and basic data types.
Ready to move on when: You distinguish a string containing digits from a number and can predict the value of each expression before running it.
Learn and practise strings, formatting, and unicode text, comparisons, boolean logic, and branching, input conversion and defensive validation.
Ready to move on when: All invalid cases fail before downstream processing; boundary values succeed.
Learn and practise lists, tuples, indexing, and slicing, dictionaries, sets, and record lookup, mutability, aliasing, and safe copying.
Ready to move on when: Your explanation identifies which object is shared at every step, rather than describing all assignment as copying.
Learn and practise for loops, while loops, and termination, comprehensions, sorting, and grouping, iterators, generators, and streaming batches.
Ready to move on when: The last partial batch is retained, invalid sizes fail, and you can explain when the generator’s work actually runs.
Learn and practise functions, arguments, return values, and scope, modules, imports, and executable entry points, type hints, optional values, and data contracts.
Ready to move on when: The missing-value behavior is explicit and you do not claim that an annotation validates incoming JSON.
Learn and practise exceptions, traceback reading, and error boundaries, context managers and reliable cleanup, debugging, logging, and reproducible failures.
Ready to move on when: You can explain the cause, show the failing and passing test, and confirm no sensitive payload is written to logs.
Learn and practise paths, text files, and safe file operations, json, csv, and schema validation, dates, time zones, and configuration values.
Ready to move on when: You distinguish event timestamps from elapsed time and never rely on bool("false") to parse configuration.
Learn and practise classes, instances, and encapsulated behavior, dataclasses, equality, and value objects, composition, protocols, and dependency injection.
Ready to move on when: Business logic can be tested without network access, and each fake failure produces the intended application outcome.
Learn and practise functions as values, closures, and callbacks, decorators and preserving function behavior, complexity, profiling, and memory-aware processing.
Ready to move on when: The results match and the report explains expected growth without claiming a universal timing from one machine.
Learn and practise unit tests, boundary cases, and assertions, fakes, integration tests, and deterministic fixtures, project metadata, reproducible setup, and cli design.
Ready to move on when: A fresh environment can follow the README and run the tests and one sample command.
Learn and practise relational tables, sql queries, and parameters, joins, aggregates, and pagination, transactions, constraints, and indexes.
Ready to move on when: The failed transaction leaves no partial local state and duplicate operation IDs are handled explicitly.
Learn and practise http requests, responses, and api contracts, api handlers, validation, and separation of concerns, authentication, secrets, retries, and idempotency.
Ready to move on when: Replays are deterministic, conflicting reuse is rejected, and the limitations of the teaching example are explicit.
Learn and practise async functions, awaiting, and bounded concurrency, threads, processes, queues, and backpressure, tabular data, arrays, and numerical-library concepts.
Ready to move on when: Unknown measurements are not counted as zero, and you can explain the difference between a scalar, vector, and table.
Learn and practise design a document-processing cli from requirements, implement and test the document-processing pipeline, python portfolio review and foundation exit checklist.
Ready to move on when: You can run, test, explain, debug, and modify the application independently. The checklist values must reflect demonstrated evidence, not simply be set to true.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Build the background needed before model-powered applications. Work through each concept and its exercise.
Ready to move on when: Explain each concept and complete its exercise before starting the AI application modules.
Separate an AI service into transport, domain logic, and dependency adapters. A request schema checks shape; domain rules check meaning. An integer quantity can pass schema validation while still violating a rule that quantities must be positive. Keep these checks independent of a model so a fake client can exercise them.
Ready to move on when: At most three fake calls run simultaneously.
A baseline answers whether a complex system earns its cost. For ticket routing, begin with a majority-class classifier or keyword rules, then compare a learned model. Accuracy alone can hide poor behavior when almost every ticket belongs to one category. Precision asks how many predicted positives were correct; recall asks how many real positives were found.
Ready to move on when: No group appears in both development and test data.
Tokenization converts text into model-specific units. A word can occupy multiple tokens, and different languages can have different token costs. Budget input, retrieved evidence, tool schemas, and output together. Character count is useful for an application limit but is not a reliable token count.
Ready to move on when: Budget checks reject requests that cannot fit mandatory instructions and the response reserve.
Treat a prompt as one versioned component of an application contract. Specify the task, available evidence, output fields, and behavior when the task cannot be completed. Examples help clarify categories, but they must represent the boundary cases rather than only easy successes.
Ready to move on when: Format errors cannot trigger downstream actions.
Retrieval quality begins before the search call. Parse documents into text with source IDs, section boundaries, version information, and access scope. Preserve headings that explain a paragraph and units that explain a table. A parser that merges two columns can create statements that were never present in the source.
Ready to move on when: Every chunk can be traced to a source location and version.
Lexical search is useful for exact product names, error codes, and identifiers. Dense retrieval can match related phrasing when words differ. Hybrid retrieval combines candidate sets, but their raw scores are not necessarily comparable. Rank fusion is one way to combine orderings without assuming identical score scales.
Ready to move on when: Report candidate recall separately from answer correctness.
A useful rubric describes observable behavior. “Good answer” is difficult to reproduce; “states the correct eligibility condition and cites the current policy” can be reviewed. Include examples of passing, borderline, and failing answers so reviewers interpret the rubric consistently.
Ready to move on when: A permission regression blocks release regardless of average quality.
Authentication establishes identity; authorization determines what that identity may do. Derive the tenant and actor from trusted server state, then scope database queries, retrieval, caches, and tool calls. A model-produced tenant ID is untrusted input.
Ready to move on when: No cross-tenant content appears in evidence, answers, or cached responses.
Different failure types call for different interventions. Missing current knowledge often calls for retrieval. An unclear instruction calls for a better task contract. Repeated style or task-format failures may justify supervised adaptation once simpler approaches have been evaluated.
Ready to move on when: The report can recommend no tuning when evidence does not justify it.
Multimodal applications need provenance at a finer level than “this file.” For an invoice, retain page number, region or bounding box where available, extracted text, and the transformation that produced it. OCR can confuse characters, merge columns, or lose currency symbols. A language model can then confidently explain corrupted input.
Ready to move on when: The inconsistent quantity example is rejected for review.
Optimize the whole request, not just tokens per second. Measure queue wait, retrieval, first output, decoding, and validation separately. Streaming can improve perceived responsiveness while leaving total completion time unchanged. Batch processing may improve throughput but increase waiting time for an individual request.
Ready to move on when: Cache keys prevent reuse across incompatible tenants or versions.
A reproducible release packages application code, dependencies, configuration schema, prompt version, and retrieval/index compatibility. Pin the environment so a new machine can run the same checks. Keep runtime secrets outside the image and fail startup clearly when required configuration is missing.
Ready to move on when: A clean setup can run one successful request from the README.
Break a user goal into observable steps and decisions. Some steps have fixed rules; others require interpretation or information gathering. Keep deterministic steps in application code and introduce model decisions only where they help. This makes failures easier to localize and prevents a model from controlling unnecessary parts of the workflow.
Ready to move on when: Every path terminates within the declared budget.
A tool runtime translates a proposed call into validated application behavior. Separate tool selection, argument validation, authorization, execution, and observation formatting. Never dispatch arbitrary names through dynamic evaluation. Use an explicit registry and make each tool responsible for domain-specific checks.
Ready to move on when: Unknown tools and unauthorized actors never reach business logic.
Working state belongs to the current task. Long-term memory influences later tasks and therefore needs stronger ownership and correction rules. Decide what can be persisted, who can read it, when it expires, and how a user can remove it. Do not convert every model inference about a user into a stored fact.
Ready to move on when: No user can retrieve another user’s records.
An agent that runs for minutes cannot rely only on process memory. Persist task state at meaningful transitions with a version number. A checkpoint should identify completed operations and pending work without requiring the model to infer what happened from prose.
Ready to move on when: Recovery does not repeat a completed side effect.
A planner proposes actions and dependencies. The runtime must check whether each action is allowed, has valid inputs, and fits the remaining budget. A plan can become stale after a tool result, so validate again when executing rather than approving the entire plan as an unrestricted script.
Ready to move on when: Unrecognized routes lead to clarification or a safe stop.
MCP gives applications a protocol for accessing tools and context from servers. Distinguish the host application, its client connections, and servers exposing capabilities. A tool is an executable capability; a resource provides context. A consistent protocol does not decide whether a tool is safe for your user or task.
Ready to move on when: The repository records protocol and SDK versions and reproducible setup.
A research agent needs a stopping rule tied to evidence, not a feeling that the answer is complete. Break the question into claims, record which sources support each claim, and identify unresolved contradictions. A source count is not the same as independent evidence: several pages may repeat the same underlying statement.
Ready to move on when: Copied summaries are not counted as independent confirmation.
Multiple agents can separate responsibilities, but they add handoffs, latency, and inconsistent assumptions. Define each role’s input, output, allowed tools, and stopping rule. A specialist should return structured findings with evidence, not an unbounded transcript for the next model to interpret.
Ready to move on when: Conflicts remain visible until resolved or escalated.
Human approval is meaningful only when the person can inspect what will happen. Store the target resource, proposed change, resource version, requester, expiry, and operation ID. The server verifies the approver’s authority and binds approval to those exact values.
Ready to move on when: No mutation occurs for changed, rejected, expired, or unauthorized proposals.
Agent correctness includes the route taken. A workflow can reach a plausible final answer after reading unauthorized data or making an unnecessary mutation. Evaluate tool choice, argument validity, access decisions, stopping behavior, and side effects separately from answer quality.
Ready to move on when: Critical boundary failures block release regardless of average score.
Interactive agents may stream text or audio before a complete response exists. Keep partial presentation separate from committed task state. A user interrupting a spoken answer should not accidentally approve a pending action or leave a background tool running without visibility.
Ready to move on when: Stale events cannot replace the current turn.
Long-running agents need admission control, per-user quotas, durable task identity, and observable terminal states. Separate request handling from workers when a task can exceed a normal request lifetime. A worker should check cancellation and remaining budget before starting the next expensive step.
Ready to move on when: A task cannot execute concurrently under two valid claims.
Build independently using an original project brief and acceptance checklist. This is a project specification, not a completed implementation.
Ready to move on when: Another engineer can reproduce the project and challenge its design using the submitted evidence.
PROVE YOUR SKILLS
Use the final review rubric to identify gaps. Lesson completion tracks study progress; readiness comes from independently demonstrating the work.
Open the portfolio review rubric →