Far-200

@far-200 source repo

11 skills
0 followers
8 hours ago last updated

▌
Dsa Tutor · far-200
Use when the user is working through a DSA or LeetCode-style problem and wants to build real problem-solving ability instead of receiving a finished solution. Guides through questions, withholds solutions until genuine struggle has happened, and logs mistakes with root causes instead of surface symptoms.

0
installs
▌
Debug Coach · far-200
Use when the learner already has written code or pseudocode, knows what it should do, and it isn't doing that — and they want the bug isolated without receiving a rewritten solution. Not for choosing an approach (use dsa-tutor), not for tracing an approach that has no code yet (use dry-run-coach), and not for plain syntax questions with no observed failure.

0
installs
▌
Concept Coach · far-200
Use when the learner wants to build understanding of a general programming, software-engineering, systems, or architecture concept — references, recursion, closures, coupling, dependency injection, caching, concurrency, queues, consistency, and similar — through Socratic coaching from their current mental model, with no concrete task behind the question. Not for an unsolved DSA problem (dsa-tutor), a DSA statement to decode (problem-decoder), tracing a concrete input (dry-run-coach), an observed failure in real code (debug-coach), deriving complexity of real code (complexity-coach), designing a test suite (test-case-coach), abstracting a pattern from a solved problem (pattern-transfer-coach), timed interview simulation (mock-interviewer), defining real feature behavior (specification-coach), or reviewing code, a diff, or a PR (code-review-coach). Not for a direct one-shot answer the learner explicitly wants with no coaching, and not a fallback for every question no specialist claims.

0
installs
▌
Dry Run Coach · far-200
Use when the learner already has an approach or algorithm in mind and needs to manually trace it, step by step, on a concrete input to verify or debug their mental model. Not for choosing an approach or writing code — use dsa-tutor for those. Teaches the actual mechanics of tracing, which dsa-tutor only names as a single stage.

0
installs
▌
Problem Decoder · far-200
Use when the learner has a raw DSA or LeetCode-style problem statement and needs to pin down exactly what is being asked — inputs, outputs, constraints, and edge cases — before any solving begins. Not for hints, approach design, or debugging; hand off to dsa-tutor once the problem is fully understood.

0
installs
▌
Test Case Coach · far-200
Use when the learner already has an approach or implementation and wants help designing a compact, justified test suite — finding missing cases, boundary values, or adversarial inputs that stress the algorithm's assumptions. Not for decoding a raw problem statement's implied edge cases (problem-decoder), not for tracing one chosen input step by step (dry-run-coach), not for chasing an already-observed concrete failure (debug-coach), and not for building the approach itself (dsa-tutor).

0
installs
▌
Complexity Coach · far-200
Use when the learner has a working approach or code and wants to determine or justify its time and space complexity. Focuses purely on Big-O derivation — nested-loop counting, recurrences, amortized cost — not on designing or debugging the algorithm itself. A standalone drill, and a deeper version of the single complexity question dsa-tutor asks during verification.

0
installs
▌
Mock Interviewer · far-200
Use when the learner explicitly wants a timed, realistic technical-interview simulation for a DSA problem rather than incremental learning support. Minimizes proactive hints during the attempt and gives structured rubric feedback only at the end. This is the opposite interaction mode from dsa-tutor — do not blend the two in one session.

0
installs
▌
Code Review Coach · far-200
Use when the learner wants to practise reviewing existing code, a diff, or a pull request through guided questioning — discovering and justifying findings one concern at a time instead of receiving a dumped list or a rewrite. The first non-DSA skill in this suite. Not for chasing an already-observed concrete failure (debug-coach), not for designing a systematic test suite (test-case-coach), not for pure Big-O derivation (complexity-coach), not for solving an unsolved DSA problem (dsa-tutor), and not for a plain exhaustive review or full refactor the learner explicitly wants delivered whole.

0
installs
▌
Specification Coach · far-200
Use when the learner has a vague feature request, issue, change request, or agent task and wants to turn it into an implementation-ready specification through guided questioning — clarifying observable behaviour, scope, non-goals, constraints, failure behaviour, acceptance criteria, and the smallest verifiable slice, without the model inventing requirements or writing the implementation. Not for reviewing existing code or a diff (code-review-coach), not for diagnosing an already-observed concrete failure (debug-coach), not for designing a systematic test suite around existing code (test-case-coach), not for decoding a DSA problem statement (problem-decoder), not for solving a DSA problem (dsa-tutor), and not for a direct request to have a complete specification, PRD, plan, or implementation delivered immediately.

0
installs
▌
Pattern Transfer Coach · far-200
Use after the learner has solved or substantially completed a DSA problem and wants to turn it into transferable knowledge — abstracting the structure away from the story, naming signals that suggest or rule out the pattern, and adapting it to exactly one cousin problem. Not for solving the original problem (dsa-tutor), not for generic data-structure or pattern definitions with no solved problem behind them (concept-coach), not for timed interview simulation (mock-interviewer), and not for complexity derivation (complexity-coach).

0
installs

11 published skills