1. LandOffer
  2. Blog
  3. All articles
  4. AI-Assisted Portfolio Code: Explain What You Built, Reviewed, and Tested

Job search

AI-Assisted Portfolio Code: Explain What You Built, Reviewed, and Tested

An original AI-generated event-count checker moves from a deliberate defect to a reviewed revision, with a complete provenance case and actually executed finite verification ledger.

9 min readLandOffer team

An AI-assisted portfolio project should let a reviewer distinguish your decisions, generated code, subsequent review and executed tests. “Built with AI” is too vague to explain your contribution. “Written entirely by me” is inaccurate when a tool generated the implementation. Describe who made each decision, what was reviewed and which checks actually ran, within the specific project or hiring task’s rules.

LandOffer publishes this guide and offers job-search tools. The original toy code and tests below were generated by an AI assistant in this session and executed locally. The assistant also reviewed and revised the code; no human code review or GitHub Copilot session was observed. Rina’s candidate case is explicitly fictional. Compare recent tech roles with the engineering judgment your own project evidence supports.

A developer separates a generated-code notebook, review notes and an executed-test record at a worktable.

Establish the rules before describing the assistance

A personal project, an open-source contribution and a hiring exercise can have different rules. Check the actual instructions for the work you intend to show. Permission to use a tool on a personal prototype does not establish permission to use it during an assessment or interview.

LLVM provides a concrete project-specific example. Its current AI tool policy requires contributors to read and review generated material, remain accountable and label substantial tool-generated content. It also prohibits using AI tools to fix issues labeled “good first issue.” That policy belongs to LLVM; it is not a universal rule for every employer or portfolio.

Record the assistance and your decisions as you work. Record what you asked the tool to do, what it generated, which parts you accepted or changed and what you personally checked. A commit history or a prompt transcript may help, but neither automatically proves understanding. Connect each important decision to an artifact and its rationale, giving a reviewer something concrete to inspect and question.

Do not put private code, credentials or other people’s data into a tool simply to produce a more impressive case study. Use material you are authorized to use. This guide does not offer a legal disclosure rule, a detector-evasion method or permission to ignore a project’s contribution requirements.

Make the contract understandable before showing the code

A small project can demonstrate useful judgment if its scope is explicit. Our toy compares the counts of event labels in two lists. It reports missing and unexpected occurrences. Repeated labels matter; event order does not. It does not parse real telemetry, inspect a filesystem or determine whether an application behaved correctly.

Inputs for this exercise are finite lists of nonempty, case-sensitive strings. “Open” and “open” are different labels. We do not claim runtime validation of arbitrary input types. Stating the contract prevents an apparently convenient normalization or sorting choice from silently changing the problem.

GitHub’s responsible-use guidance notes that generated suggestions can be inaccurate and need review and validation. Generated tests also need review because they may miss scenarios. Treat those as reasons to inspect the contract and expected results, rather than assuming plausible code or a green test run establishes the right behavior.

Worked asset 1: provenance, review and a finished project explanation

This deliberately flawed starting version was AI-generated for the guide. It was not captured from a real candidate’s project or a Copilot failure, and it is not evidence of a provider’s typical performance:

def reconcile(expected, observed):
    return {
        "missing": {x: 1 for x in sorted(set(expected) - set(observed))},
        "unexpected": {x: 1 for x in sorted(set(observed) - set(expected))},
    }

The defect is specific. Sets preserve membership but discard multiplicity. If the expected list is ['open', 'save', 'save'] and the observed list is ['open', 'save'], both sets are identical. The function reports no missing event, although one save occurrence is missing under our contract.

The assistant reviewed the multiplicity defect and generated this revision, which keeps occurrence counts and returns positive differences in each direction. This was not human review:

from collections import Counter

def reconcile(expected, observed):
    want, seen = Counter(expected), Counter(observed)
    return {
        "missing": dict(sorted((want - seen).items())),
        "unexpected": dict(sorted((seen - want).items())),
    }

want - seen retains positive deficits in the observed list. Reversing the subtraction captures extra observed occurrences. Sorting the output entries makes their presentation deterministic; it does not make input sequence order a requirement. The function does not modify either input list.

The completed provenance record for this actual exercise is:

Artifact or decision What happened in this session Claim boundary
Contract The assistant specified count comparison, case sensitivity and ignored sequence order No real candidate requirements workshop occurred
Starting code The assistant generated an intentionally flawed set-based function Not an observed Copilot output or model benchmark
Revision The assistant identified lost multiplicity and generated the Counter revision AI review, not independently observed human review
Verification AI-generated tests were executed locally; results are recorded below Finite assertions, not a security or licensing assessment
Human contribution No manual human review or implementation was observed The user must not be credited with unobserved work

Rina is a fictional candidate using this exercise to illustrate a project description. In the fictional case, she personally chooses the contract, reviews both versions and understands the test evidence. Those human actions are stipulated, not events we observed. Her complete sample case reads:

Event-count comparator — offline Python prototype. I defined count-based reconciliation so repeated labels remained meaningful, with case-sensitive matching and sequence order outside scope. AI generated the initial function and revision. I reviewed the loss of multiplicity in the set-based version and selected the counterexample and verification scope. The checked revision passed seven named cases and 225 finite input pairs. This compares synthetic labels only; it does not validate a real application, establish code licensing or demonstrate production security.

That account names the decisions instead of implying that typing every line was the contribution. For your own case, retain only the actions you actually performed. If an assistant chose the requirements, wrote the tests and interpreted the result, say so until you have personally completed the review you intend to claim.

Explain the checks and their blind spots

A test report becomes useful when another person can understand the expected result and why the check matters. The initial function could pass a happy-path example with distinct labels while failing its central requirement. Repeating that easy case would not improve the evidence.

Keep the failing input, expected output, observed output and revision together. A reviewer should be able to see which problem the change addresses and what remains outside the test scope. Avoid replacing that explanation with a test count or a claim that the tool “fixed everything.”

GitHub’s current agent application card describes code review as a supplement to human review and warns about limitations. An AI review comment is another input to assess; it does not replace a person understanding and evaluating the code. In this guide, the assistant’s own review is labeled accordingly.

A developer examines a missing repeated event in an abstract test trace while keeping a separate limitations note open.

Worked asset 2: a completed finite verification ledger

We executed seven named cases against both functions. The seven cases separately check empty lists, a missing duplicate, extra duplicates, different labels, case-sensitive labels, reordered inputs and balanced repeated labels. The expected outputs were checked through a separate oracle that uses each label’s list.count result rather than Counter subtraction.

Named check Expected result Starting version Reviewed revision
Expected open/save/save; observed open/save Missing save: one Incorrectly reports no difference Reports the missing occurrence
Expected save; observed save/save/save Unexpected save: two Incorrectly reports no difference Reports two extra occurrences
Expected open; observed close Missing open: one; unexpected close: one Matches Matches
Expected Open; observed open Two distinct labels, one missing and one unexpected Matches Matches
Same labels in reversed order No difference Matches Matches
Empty lists or equal repeated labels No difference Matches both named cases Matches both named cases

We then enumerated every sequence of length zero through three over the labels open and save. There are 15 such sequences and 225 ordered pairs. For each pair, the script checks the reviewed result against the count-based oracle, checks invariance when both inputs are reversed and checks that the original input lists remain unchanged.

The starting version disagrees with the oracle on 166 of those finite pairs. The reviewed revision disagrees on none. These are actual local execution results for this deliberately constructed exercise, not an AI accuracy rate, a productivity comparison or evidence about a real employer’s codebase.

The completed decision is to keep the revision for this narrow prototype contract and retain the starting counterexample in the explanation. That decision applies only to retaining the local teaching prototype, with no deployment or real application integration performed. The finite alphabet and length bound do not exhaust arbitrary strings, large inputs, memory behavior or misuse. The tests also do not establish event ordering, timestamps, uniqueness of real events or correctness of a source log.

The oracle itself still deserves inspection. An AI-generated oracle can repeat an implementation mistake or encode the wrong requirement. Here its label-count arithmetic and named examples make the intended result inspectable; a passing comparison alone would not establish that the product contract was appropriate.

Keep licensing, security and understanding as separate evidence

GitHub’s documentation on public-code references explains that generated output can match public repositories and that references can help inspect matching code and licensing information. Its index does not cover all code everywhere. The absence of a reference is not a complete rights analysis, and functional tests do not settle attribution or permission questions.

For your project, review relevant dependencies, copied material, tool output and applicable project rules. Do not claim “license checked” because unit tests passed or “secure” because a reviewer tool reported no issue. If a check was not performed, retain that gap in the case note instead of giving the project an unsupported badge.

You should also be able to explain the implementation without delegating the conversation back to an assistant. For this toy, that means explaining why sets lose counts, why subtraction is directional and why order is deliberately ignored. If you cannot yet explain those choices, study the implementation and work through the counterexample before claiming personal review. Keep that learning step separate from the checks already executed by an assistant.

Present a contribution a reviewer can inspect

Use a short project opening that names the problem and bounded result. Follow it with the assistance used, the decisions you personally made, one meaningful revision and the evidence you actually executed or reviewed. Keep a fuller provenance record available for the questions that follow. A small evidence bundle can contain the starting function, revised function, test script and saved results from the same run. In this exercise, those artifacts let a reviewer trace the missing-duplicate example to the code change and the finite checks. A screenshot of passing output alone would not identify which implementation produced it.

Keep the result attached to the tested revision. If you later change case sensitivity, input validation or the meaning of repeated events, update the contract and rerun the affected checks before reusing the old success statement. A change to the contract can invalidate an earlier result even when the function still runs. Preserve failed examples as part of the explanation rather than deleting the evidence that motivated the revision.

Before an application or contribution, compare that account with the specific instructions. Adjust the work or withhold it when it does not meet those rules; do not assume a general AI policy overrides a task’s restrictions. No assessment or interview tool permission follows from this portfolio example.

The goal is an accurate explanation of engineering work, including AI assistance and unresolved checks. Use LandOffer’s job-search tools to find relevant opportunities, then show the project decisions and verification you can personally substantiate.

Sources and Further Reading