A generated diff can compile, pass the tests it wrote for itself, and still be wrong. That is the premise of this guide’s practice material. This page has two parts. The first reports what the software engineering listings on micro1’s portal say the work is, taken from their full descriptions. The second is this guide’s own practice material: six failures to look for in code, and how an engineer who has shipped and maintained software catches each one.
Which listings are open changes; check the portal rather than this page for what exists today.
Opens micro1. You apply and are vetted by micro1, not by this site.
What the listings describe: mostly building, some reviewing
We read the full description of every software engineering listing in our inventory on the date in Sources. Titles repeat (“Senior Software Engineer” appears on several different projects), so the title tells you little; the description is what separates them. They fall into five kinds of work.
Building tasks and environments for models to be tested on. This is the largest group. The descriptions ask the expert to create realistic, hard coding tasks from real repositories and, for each one, to define the problem, build a reproducible environment, write deterministic verifiers and provide a reference solution. One description spells out what the verifier must do: accept correct solutions across different valid implementations while rejecting incorrect, incomplete or hard-coded ones. Variants of the same work cover DevOps, CI/CD and debugging workflows with command-line tools such as git, docker and gdb; tasks that have to be solved through Model Context Protocol tools; and, for competitive programmers, a custom problem absent from existing online judges with its reference solution, test suite and checker.
Implementing and debugging inside repositories, and reviewing generated patches. The open source and full-stack descriptions list exploring unfamiliar repositories, implementing and debugging front-end and back-end components, writing unit, integration, regression and end-to-end tests, and reviewing AI-generated patches for correctness, completeness, security and maintainability.
Reviewing patches for a repository you maintain. One listing is for open source maintainers: evaluate patches an LLM generated for your own repository, justify each assessment in writing, and peer-review other experts’ assessments.
Evaluating AI tools in developer workflows. One description asks for structured evaluation assignments that simulate version control, code review, issue tracking and CI/CD with AI-powered tools, grading the outputs hands-on, seeding reproducible test repositories, and taking part in calibration sessions so graders stay consistent.
Documents rather than code. Two listings with engineering titles are about written material: one about reconstructing and designing technical presentation slides, one about reviewing AI-generated technical content against rubrics and drafting design documents and proposals.
So the common picture of this work as reading a diff and marking it pass or fail fits only part of it. In most of these descriptions you write the task, the environment, the checker and the solution. Requirements differ as well: the open source listings require a verifiable public profile with real contributions, and several descriptions state that prior AI experience is not a requirement.
How the six failure classes were chosen
Everything from here to the grid is the blog’s material, not the listings’. The six classes below are an editorial selection, not a measured ranking of model failures. The engineering references in Sources support the mechanisms: inadequate tests, repeated side effects, excessive queries, exception handling and removed APIs. The final class is a consistency check between explanation and code. These issues can occur in human-written code too. The exercises and grid are ours, not a classification or assessment published by micro1, and have not had specialist review. Each class names the kind of work, from the section above, that its exercise is practice for. Most are practice for building tasks and environments and for reviewing generated patches. Nothing here practices the two document-centered listings or the evaluation of AI tools in developer workflows. All code in the exercises is code you write for the purpose.
The examples below are illustrative exercises created for this guide, not published micro1 assignments or interview questions. They show the kind of judgment the work needs; they are not a preview of what a project will hand you.
Each section says what the failure is, how it shows up in a diff, and one way to practice catching it.
Our class 1: it passes the tests it wrote for itself
What it is. In this hypothetical failure, the tests encode the same misunderstanding as the code: a green suite leaves the disputed requirement untested. Google’s code review guide asks whether tests actually fail when code is broken; that is the check to apply here.
How it shows up. The assertions mirror the implementation line by line; the edge case named in the ticket never appears in a test; every fixture is the happy-path input.
How an engineer catches it — exercise: write the test that exposes it. Practice for: reviewing generated patches, and writing verifiers. Take a plausible-looking implementation and produce the minimal test that fails. A failing test can be run by the next person, which a comment cannot.
Our class 2: right on the first call, wrong on the second
What it is. Code that is correct once and wrong under repetition: no idempotency, no handling of partial failure, retries that duplicate effects.
The Amazon Builders’ Library illustrates this risk with a request that succeeds but loses its response: retrying can create a second resource unless the API’s contract makes the retry safe.
How it shows up. A handler that charges, sends or inserts without checking whether it already did; a loop that retries a whole batch after one item failed.
How an engineer catches it — exercise: adversarial task authoring. Practice for: building tasks for models to be tested on. Write a task that looks routine and has a requirement that is easy to miss: an endpoint that must be idempotent, a migration that runs while writes continue, a cache that must not serve stale reads after invalidation. Write the pass criteria before any model runs, then try it on a model you may use.
Our class 3: correct output, unacceptable cost
What it is. The answer is right on a small input, but the implementation exceeds the task’s resource budget on a larger one. EF Core’s performance guide gives concrete examples: an extra database roundtrip per item and result sets whose memory use grows with the data.
How it shows up. A query inside a loop, a full-collection sort to find one item, an allocation that grows with input nobody bounded.
How an engineer catches it — exercise: label the class, not pass/fail. Practice for: reviewing generated patches. Given a task and a generated solution, label the failure: wrong output, correct-but-racy, correct-but-unbounded, correct-with-swallowed-error, or correct. A bare pass/fail hides which of these you saw.
Our class 4: the error that is logged and swallowed
What it is. A handler logs an error and reports success although the required result is missing or incomplete. Recovery that the task permits and that produces a valid result is not this failure. The Python tutorial shows the distinction between handling an exception and logging it before raising it again for the caller.
How it shows up. In the exercise, no test forces the failing write: the suite stays green while a failed write can leave a missing record that the caller believes was saved.
How an engineer catches it — exercise: two-candidate review. Practice for: reviewing generated patches and justifying each assessment in writing. Write two diffs for the same invented ticket: one clean that drops an error, one uglier that handles it. Score both against the grid below and write the justification a third engineer would accept.
Our class 5: an API from two releases ago
What it is. Using an API that is absent or incompatible in the pinned version. Deprecation
alone does not mean a call already fails. A concrete removal: Python 3.12 dropped the imp
module; its release notes give importlib replacements.
How it shows up. Code that reads idiomatically and fails at import or at runtime against the version the project actually pins.
How an engineer catches it. Read the dependency manifest before the diff, and check each unfamiliar call against the documentation for the pinned version rather than against memory. Practice for: implementing and debugging inside repositories. A habit to rehearse, not a published task.
Our class 6: the explanation describes a different diff
What it is. The commentary describes what the code should do, not what it does.
How it shows up. In this invented example, the summary claims that empty input is rejected, but the function accepts it. Compare that statement with a run on empty input. This is a test case for explanation accuracy, not a claim about how often models make this mistake.
How an engineer catches it — exercise: reasoning-trace review. Practice for: reviewing generated patches. Read the model’s stated reasoning next to its code and mark every point where they diverge.
Our grid for a generated diff
This grid is ours, not micro1’s. It turns the six classes into something you can score against. Levels are cumulative: Strong is Acceptable plus the thing named after “also”, and a row sits at the highest level the diff meets in full. A row you could not check — the diff never ran under concurrency, say — is at Fail until you check it. A diff with any row at Fail is rejected, however many rows reach Strong; the Fail cell names what to fix, and a diff rejected only on Explanation needs its explanation corrected, not its code.
| Criterion | Fail | Acceptable | Strong |
|---|---|---|---|
| Correctness | Wrong output in at least one case, including under retry or concurrency. Correct the code path that is wrong | Correct output in every case you ran, including under retry and concurrency | Also: the assumptions about retry and concurrency are written down |
| Error handling | At least one error leaves the result wrong, incomplete or missing, and nothing lets whoever depends on that result know — a log line does not count. Correct that handler; Clarify first if the task does not say whether the recovery is allowed | Every error ends one of two ways: a recovery the task allows, with a valid result, or a failure passed to the caller | Also: each error passed to the caller carries the context needed to act on it |
| Resource use | At least one step does more work than the task needs as the input grows — a query per item, a full sort to find one item, an allocation with no cap. Correct it, or Clarify where the cap lives if it is outside the diff | No step does more work than the task needs as the input grows | Also: the input size it assumes is stated |
| Tests | Some part of the requirement can be broken with every test still passing. Correct the tests: add the one that fails | For each part of the requirement, a test fails when that part is broken | Also: the edge case the task names has a test of its own |
| Explanation | Describes something the code does not do, or is missing where the task asks for one. Correct the explanation | Every statement in it matches the code | Also: names the trade-off taken |
Writing a grid of your own before looking at a diff makes you say what “good” means first.
Profile, employer agreement and rates
No universal credential is published, and requirements are set per listing — languages included. What makes a profile matchable:
- Languages with the context you used them in. “Go, four years, a payments service” says more about fit than a list of twelve languages.
- Production ownership. On-call, incidents, migrations — said truthfully, without your employer’s confidential detail.
- Test and tooling experience. Most of the descriptions ask for verifiers, test suites and reproducible environments; if you have built those, say so.
- Review experience. Several descriptions list reviewing generated patches or other experts’ submissions.
- Open source, if any. Some listings require a public profile with substantial contributions and say that documentation fixes and dependency bumps alone are not enough.
ML experience is a per-listing question: each listing sets its own requirements, so check what it asks for.
How the pay is described
The listings give signals that do not match. The cards on the opportunities page show an hourly range. Most descriptions give the role type as a contractor at about fifteen hours a week, with a flexible schedule. And most of them then say:
Compensation is output-based; experts are paid per task that meets the project specifications. The time required to complete work may vary depending on the expert’s experience and workflow. Minimum submission requirements apply. Experts must submit a minimum of tasks per week.
Two descriptions show the mismatch inside a single page: an hourly pay range at the top and output-based, per-task compensation near the bottom. None of the descriptions we read says what one task pays, how many tasks the weekly minimum is, or what happens to a task that is rejected. A few descriptions state no compensation structure at all.
Treat the hourly range as the listing’s headline, not as a promise that each hour is paid. Building a task with an environment, a verifier and a reference solution can take much longer than planned, and where a description states per-task pay the overrun may lower what the task pays per hour in effect; the contract is what says how it is treated. Before accepting, ask in writing what a task pays, what counts as accepted and who decides, whether rejected work can be resubmitted, and what the weekly minimum is.
Rates are left out of this guide because we chose to leave them out. The referral terms say something narrower: nobody promoting the program may make promises about compensation, placement or acceptance.
Two things to settle for yourself before applying:
- Your employment agreement. It may restrict outside work or assign IP to your employer. Read it before you accept, not after.
- Do not bring your employer’s code. Write hypotheticals, including when you reach for a familiar example.
The AI interview
An AI interview — step two of the four micro1 lists, between applying and onboarding — plus human recruiters who, per micro1, review profiles and match experts to opportunities based on verified skills. Several descriptions give their own sequence: screening questions, an AI interview of about half an hour, a technical assessment marked as tentative, and a hiring manager review. One asks that the interview and the assessment be completed without outside assistance.
Ways to prepare, as suggestions from this guide:
- Have one incident ready, ninety seconds. What broke, how you found it, the fix, and what you changed so it could not recur. A true one, told without your employer’s confidential detail.
- Practice reviewing out loud in reviewer order: correctness, failure modes, resource use, readability.
- Name assumptions explicitly — isolation level, timeout budget, expected cardinality.
- Say what you do not know. It is the same thing the grid above asks of a diff’s explanation.
Countries, and two last questions
micro1 states it does not hire residents of: Afghanistan, Belarus, China, Cuba, Democratic Republic of the Congo, Hong Kong, Iran, Iraq, Libya, Macao, Myanmar, North Korea, the Russian Federation, Somalia, South Sudan, Sudan, Syria, Venezuela, Ukraine and Yemen. Snapshot from the date in Sources.
Am I training my replacement? You are training and measuring models on engineering tasks. That is a fair thing to decline over, and this page will not argue you out of it.
Will a referral link get me a better review? Not that we can find. The vetting is micro1’s, and this site plays no part in it. micro1’s referral terms also forbid anyone promoting the program from promising placement, compensation or acceptance. Read a page that claims a referred engineer is treated better as a warning sign.