MyAIDevelopment · Product · Operations notes

Reverse Engineering: Law and Lawful Uses

Learning goal: Explain what reverse engineering is and why people do it, tell apart the boundaries set by Korean, US and EU law and by contracts, and carry out competitor product analysis and your own legacy decoding within lawful limits, verifying as you go.

A solo studio runs into reverse engineering too: when it studies a competitor's pricing, and when it has to reread its own code and data files that were left without documentation. This document covers the legal boundaries and lawful uses, not analysis techniques. Permissions to give an agent are in "Permissions, Sandbox, Hooks"; what to show the model in "Layers of AI Engineering: Prompt, Context, Harness"; the repeating structure that feeds verification back in "Loop Engineering"; and who owns outsourced code in "Contracts · IP · Open Source". Statutes and cases are as of 2026-09; items confirmed only through search results, because the original could not be opened directly, are marked in the references.

This document is general information, not legal advice. Legal interpretation depends on the facts and on timing. Consult a lawyer before analysing anyone else's software or service.

Key Concepts

Definition

Forward engineering goes from requirements through design and implementation to a finished product. Reverse engineering runs the other way. It starts from a finished product and recovers its design, structure and behaviour. A good output is not a copy of the original but an explanation with evidence. Sentences such as "the payment screen appears after the 7-day free trial" or "the first field of this save file is a version number", together with a way to check them again, are the result.

Why people do it

Even with the same purpose, the target and the method decide whether it is lawful. The principles below cover that boundary.

Principles

Korea: reverse analysis of program code under the Copyright Act

Korea: trade secrets and information networks

The US and the EU

Contracts: EULAs and ToS

Software EULAs and service terms of service (ToS) commonly prohibit reverse engineering, automated collection, unofficial clients, use for developing or benchmarking competing products, and publishing benchmark results. How far such clauses can narrow what Article 101-4 allows in Korea was not confirmed for this document. Apart from the legal answer, the practical risk is clear: account bans, loss of app store or API access, breach-of-contract claims and broken partnerships. For a solo studio, a single account ban can halt the business.

"May I do this?"

flowchart TD
    A[What you want to analyse] --> B{Is it your own code or data}
    B -->|Yes| C[Proceed: verify explanations with tests]
    B -->|No| D{Does it need bypassing protection or private server access}
    D -->|Yes| W{Is there written permission or a bug bounty scope}
    W -->|Yes| S[Proceed only within the permitted scope]
    W -->|No| X[Do not do it]
    D -->|No| E{Are you only observing as a normal customer}
    E -->|Yes| F{Do the terms prohibit this use: benchmarking and competing development included}
    F -->|No| G[Generally fine: internal reference only]
    F -->|Yes| L[Stop and consult a lawyer]
    E -->|No| H{Is it for interoperability with no other source of the information}
    H -->|Yes| L
    H -->|No| X
Scenario Conditions under which it is allowed Risk (general judgement)
Signing up to a competitor normally and recording screens, pricing and onboarding Normal sign-up and payment, manual observation, internal use, no benchmarking or competing-development ban in the terms Low without such a clause, high with one
Integrating through public docs, public APIs or SDKs Follow the documented terms and rate limits Low
Decoding your own code, outsourced code whose rights you received, or your own data files Ownership confirmed by contract Low
Analysing purchased software to build a compatible tool Article 101-4 conditions met, EULA checked, advice first Medium to high
Authorised security testing Only within written permission or a bug bounty scope High without permission
Analysing a competitor's app to carry over features or code Not for interoperability; may hit the similar-program ban High
Automated collection of a competitor's data through a private API ToS breach; Network Act and unfair competition issues High
Defeating DRM or licence checks Prohibited outside the narrow exceptions of Article 104-2 High
Reusing or redistributing extracted images, audio or fonts Not without the rights holder's permission High

Applied: Lawful Reverse Engineering in a Solo Studio

Competitor teardown: use it as a customer and record

Sign up as a normal customer and pay if needed. Record only what a person sees while using the product, with no automation tools and no private paths.

What to record What to write down Where it is used
Onboarding Number of sign-up steps, time to first value, information requested Activation design
Pricing Plan names, prices, free limits, trial length, annual discount, cancellation steps Pricing design
Funnel When payment is prompted, paywall placement, order and spacing of emails and pushes Lifecycle design
Feature structure Menu structure, feature differences by plan, missing features Positioning, roadmap
Customer voice Recurring complaints and praise in public reviews Differentiation hypotheses
  1. Before signing up, look in the terms for clauses banning use for competing development or benchmarking and banning publication of benchmark results, and record them with the date. If one exists, follow the lawyer path in the flowchart above.
  2. Collect the records in one table with dates and screenshots. Prices and terms change often.
  3. Compare several competitors in the same columns and mark what everyone does and what nobody does.
  4. Turn the gaps into customer problems, test them in interviews from "Market & Customer Research · Segmentation", and put them into "Discovery · Strategy · Roadmaps".
  5. Turn the confirmed differences into a positioning statement using "Positioning · Messaging · Brand". Set prices with the framework in "Paid Sales, Subscriptions and Pricing".
  6. Before naming a competitor in ads, read "Law · Ethics · Ad Disclosure". Keep screenshots and copy as internal material and do not publish them.

Reading your own legacy code and data files with an AI agent

When you need to understand your own undocumented code, or save files your own app produced, an AI agent is a fast assistant. But the agent's explanation is a hypothesis, not a fact. A plausible but wrong explanation is the most dangerous kind.

  1. Confirm ownership: check by contract that the code is yours or that its rights were transferred to you.
  2. Separate the workspace: work on a copy, not the original, and narrow the agent's write and network permissions ("Permissions, Sandbox, Hooks"). Use only sample files your own app produced, and anonymise them first if customer data is mixed in.
  3. One question at a time: ask narrowly, such as "how does this function write the version field of the save file", rather than "what does this module do".
  4. Record explanations as hypotheses: attach one line on how to check each agent explanation.
  5. Verify by running: run the existing tests, add characterization tests that pin current behaviour, and compare the outputs of the old program and the new code on the same input. The golden file is produced by actually running the legacy program; never write it by hand from the agent's explanation. If it fails, revise the hypothesis and ask again ("Loop Engineering").
  6. Document only what is confirmed: move only explanations that passed verification into the README or format documentation.
# Characterization test: pin today's behaviour before trusting any explanation
# The golden file comes from running the legacy program, never from the agent's explanation
import json
import subprocess

def test_new_reader_matches_legacy_output(tmp_path):
    out = tmp_path / "new.json"
    subprocess.run(["python", "new_reader.py", "samples/save_001.dat", str(out)], check=True)
    legacy = json.loads(open("samples/save_001.legacy.json", encoding="utf-8").read())
    assert json.loads(out.read_text(encoding="utf-8")) == legacy

Going Deeper

Where the lines blur

When to call a lawyer

Common Misconceptions

Self-Check Questions

  1. Can you explain the three conditions in Article 101-4(1) and the limits on use in Article 101-4(2)?
  2. In a competitor teardown, name one permitted observation and one action to avoid.
  3. How did the criminal judgment in 2021Do1533 differ from the reported civil first-instance ruling, and what is the lesson for a studio?
  4. How do EU Article 8 and the SAS ruling differ from Bowers v. Baystate and Vault v. Quaid on the effect of contract clauses?
  5. When an AI agent explains a legacy file format, what would you use to verify that explanation before putting it in documentation?

References