Agents are useful when the parser's contracts stay in charge.
Jsonic++ development can use AI aggressively for corpus generation, fuzz triage, parser review, performance investigation and implementation work while keeping the human responsible for scope, semantics and acceptance.
Good use of an agent
Parsers are unusually suitable for agent-assisted adversarial work because the desired behavior can often be reduced to tiny inputs. Ask an agent to generate neighboring valid/invalid cases around a grammar rule, compare behavior against a reference corpus, minimize a sanitizer failure, or search the implementation for an entire bug family rather than one symptom.
- generate number, escape, nesting and duplicate-key edge families;
- minimize fuzz failures into readable permanent fixtures;
- review parser/writer symmetry and round trips;
- inspect synchronization diffs across vendored consumers;
- benchmark proposed changes before accepting complexity justified as “faster.”
Evidence over assurance
An agent saying “the parser handles Unicode” is not evidence. A permanent test covering valid surrogate pairs, lone high and low surrogates, malformed escapes and round trips is evidence. The same rule applies to duplicate keys, number grammar, serialization and API behavior.
Failure conversion
When an agent finds a parser bug, preserve the smallest reproducer and add it to the permanent suite before considering the work complete. Then broaden the search: if one malformed exponent slipped through, test the surrounding number grammar rather than storing only the exact string that happened to fail.
Human responsibilities
The human still decides whether a behavior is a bug, what compatibility means, whether a new feature belongs in the library, and whether implementation complexity is justified. An agent can implement a JSON Pointer subsystem quickly; that does not make JSON Pointer part of Jsonic++'s purpose.
Review loop
- State the behavioral contract in plain language.
- Ask the agent to identify relevant implementation paths and existing evidence.
- Add or design failing/adversarial tests before broad changes.
- Implement the smallest change that satisfies the contract.
- Run standalone, sanitizer and synchronized-consumer checks.
- Keep the reproducer and update project documentation if the public contract changed.
Why the small codebase matters
Agentic development becomes safer when the implementation can be re-read cheaply. Jsonic++'s one-header architecture makes whole-component review plausible after meaningful edits. That reduces the temptation to accept a patch simply because a local test turned green.
For the broader workflow and the distinction between direction and implementation, see Human-directed agentic engineering.