How to practice manual coding in your own projects

Pick one behavior your repository already needs, not a new feature invented for practice. A useful manual rep has a narrow scope, a failure you can reproduce, and a local check that tells you when to stop.

For example: search results sometimes jump back to an older query. Reserve the response-ordering fix, not the entire search screen. If your project has no such problem, use the example below as a local exercise or choose a different real task; do not introduce a bug just to repair it.

Target: async reasoning and regression testing. Budget: about 20 minutes. Scope: one search adapter and its test file.

• The most recently started request is the only one allowed to publish results.
• A single request must still work, and an empty result must clear previous results.
• Do not redesign the UI, add dependencies, or change debounce, caching, authentication, or API behavior. Error handling and cancellation remain separate tasks.

Ask your local coding agent to identify the relevant scope and acceptance check, then stop editing it. Turn off inline AI completion for that scope. You write the fix yourself; any help you use should be recorded honestly, not presented as independent work.

This standalone JavaScript example needs Node.js 22 and no packages, account, network, or production data. Create a fresh scratch directory and save the following as search.mjs. This is deliberately incorrect starter code, not a production patch.

export function createSearch(fetchItems, showItems) {
  let latestRequest = 0;
  return async function search(query) {
    const request = ++latestRequest;
    const items = await fetchItems(query);
    showItems(items);
  };
}

Save this test beside it as search.test.mjs. Controlled promises force the older response to arrive last; there are no timers or real API calls.

import assert from "node:assert/strict";
import test from "node:test";
import { createSearch } from "./search.mjs";

function deferred() {
  let resolve;
  const promise = new Promise((done) => { resolve = done; });
  return { promise, resolve };
}

test("newest request wins when responses arrive out of order", async () => {
  const first = deferred();
  const second = deferred();
  const shown = [];
  const search = createSearch(
    (query) => query === "first" ? first.promise : second.promise,
    (items) => shown.push(items),
  );
  const older = search("first");
  const newer = search("second");
  second.resolve(["new result"]);
  await newer;
  first.resolve(["old result"]);
  await older;
  assert.deepEqual(shown, [["new result"]]);
});

test("a single request still displays its result", async () => {
  const shown = [];
  const search = createSearch(async () => ["result"], (items) => shown.push(items));
  await search("query");
  assert.deepEqual(shown, [["result"]]);
});

test("an empty newest result clears the previous results", async () => {
  let visible = ["previous result"];
  const search = createSearch(async () => [], (items) => { visible = items; });
  await search("no matches");
  assert.deepEqual(visible, []);
});

From that directory, run:

node --test search.test.mjs

Before the fix, expect one failing test and two passing tests. The failing test shows that the old result was published after the new result. If you see an import or runtime error instead, fix the file names or Node setup first; that is not evidence of the bug.

Before editing, explain when request becomes stale relative to latestRequest. Put the smallest guard at the point where an awaited result would be published. Do not weaken the assertions to make the test green.

1. Run the same command again. All three tests should pass.
2. Temporarily undo only your guard and rerun: the ordering test should fail again. Restore the guard and confirm all three pass.
3. In a real repository, adapt the regression to the existing test runner and run the relevant existing tests too. Review the local diff: only the reserved scope should change.
4. Explain why a slow older response cannot replace a newer one, and list what this test does not cover: errors, cancellation, unmounting, and your actual UI integration.

Stop if the fix requires unrelated refactoring or exceeds the time budget. Re-scope the task or use a Gym rep instead. Passing this scratch example is local practice, not a verified ManualMode Project rep or a claim that your application is production-safe.

ManualMode Project Mode uses bounded task metadata and local verification evidence. Raw source stays local by default; ManualMode does not run your repository code on its server. Share only the required bounded metadata, hashes, test counts, outcome, and assistance usage.

Do not paste repository source, diffs, prompts, transcripts, raw command output, secrets, customer data, or internal paths into analytics or support messages. Optional source sharing requires separate, explicit consent. Your coding agent has its own provider and privacy settings: a local workflow does not mean that agent never sends context to its provider. Review those settings and use only a repository you are allowed to connect.

Create an account directly using Start free; the public review is optional. The free allowance is 3 Gym + 1 Project reps, with no card required. This guide keeps your Project intent through signup and onboarding, then opens Project setup.

1. Complete your training profile and connect a supported coding agent from Project setup.
2. ManualMode supplies a skill target and time budget. Your agent proposes bounded tasks from an opted-in repository; ManualMode must approve and reserve one before it can count.
3. Keep the reserved scope manual. Run the agreed local verification and submit the required bounded evidence through the connected workflow.
4. Check the recorded outcome in the app. A locally passing test alone does not award progress; accepted completion evidence updates the shared skill profile.

Project Mode uses your repository language and local runtime. Browser Gym currently executes JavaScript and is a fallback when no safe, right-sized repository task fits. You do not need to complete the public review to use either path.