[DSRP Evidence](https://dsrpevidence.org/)

# Feature-Controlled Programming: Embedding structural commitments in AI-assisted software development: an industrial case

## Details

**Authors** Silberman, Dave and Das, Sree Kumar Valath Bhuan

**Year** 2026

**Publisher** Journal of Systems Thinking, vol. 6, no. 4 (Academy of Systems Thinking)

**Kind of work** article

**Discipline** Computer Science & AI

**Secondary disciplines** Systems Science

**Kind of engagement** scholarly

**Applied** false

[Read it at the publisher](https://doi.org/10.54120/jost.v26i1.ywrqbnt) 
10.54120/jost.v26i1.ywrqbnt

## In authors' words

### What they set out to do (purpose)

To show that the structural commitments a programmer normally carries in their head can be made explicit as rules enforced by a development environment, and to document an industrial case in which this was done. The authors state the case is offered as evidence that the method can be operationalized, not that it outperforms alternatives.

### Who or what was studied (sample)

A small distributed team of three administrators building a commercial systems-mapping platform with AI-assisted coding, observed across 50 days, 513 deployments and 155 unique features.

### How they did it (methods)

An observational single-case report. Six procedural rules were built into the team's development environment: a clarity gate that refuses a feature card until its name, purpose and expected behavior are stated; single-programmer checkout with the holder publicly identified; a component map that flags features sharing parts; a serial law giving each feature a persistent, never-reused identity across lifecycle states; declared relationships stating dependencies, effects, blocks and extensions; and a short check-out, build, check-in, release, observe, rework cycle. Because the rules are enforced by tooling rather than by exhortation, routine work emits a behavioral event stream, which the authors tabulate.

### What they found (results)

The authors record zero clarity-gate refusals, 44 overlap alerts, 513 releases, 85 rework events and three merge collisions, two caught by the system's guard and one reaching the code. They read each rule through the DSRP-484 grammar: the clarity gate forces a Distinction by requiring identity and boundary to be stated; the component map makes part-whole Systems countable; relationship declaration makes Relationships explicit and writable; checkout makes the active Perspective visible; and the serial law and alignment cycle carry identity-through-change and model-reality feedback. They claim the case shows the method runs under commercial pressure and that the event stream supports prospective hypotheses, such as whether overlap alerts predict later rework. They decline comparative claims, citing the absence of a control group, a matched conventional team and a clean pre-adoption baseline, and their own involvement in the case: 'We should not turn a case into an experiment by adjective.' They conclude that when structure is built into the environment, 'structure stops being advice and starts being architecture.'

## Commentary

### In short

Silberman and Das build the four patterns into the rules of a software development environment, mapping each rule of Feature-Controlled Programming onto DSRP-484, and report fifty days of production use on a commercial systems-mapping platform.

### In more detail

This is DSRP used as a specification for tooling rather than as a way of talking about a problem. The authors argue that AI-assisted coding has made implementation cheap without making structural judgment cheap, so the scarce skill moves upstream: deciding what to build, where its boundaries fall, how its parts relate, and from whose vantage it is framed. Those are the four patterns, and the paper's move is to stop asking programmers to hold them in mind and instead make the environment refuse work that leaves them unstated. Each rule carries a pattern. The clarity gate will not accept a feature card without a name, a purpose and an expected behavior, which forces the identity-other boundary before any code is generated. The component map ties features to product parts and raises an alert when two features share one, which turns part-whole structure into something countable. Relationship declaration requires dependencies, effects, blocks and extensions to be written down rather than discovered at merge time. Single-programmer checkout names publicly who holds a feature, which the authors read as making the active perspective visible. Two further rules sit outside the one-to-one mapping: a serial law giving each feature a persistent, never-reused identity, applying object persistence a level above the code, and a short check-out-to-release cycle that functions as the model-reality alignment loop. The measurement claim follows from the enforcement. Because the rules are procedural, ordinary work leaves a record: 44 overlap alerts, 513 releases, 85 rework events, three merge collisions, and zero clarity-gate refusals across the window. The authors treat these two ways, descriptively and as the basis for testable predictions, and they are explicit that the case shows operationalizability and nothing more. They name the limits themselves, including that they built the framework and are part of what they are observing.

### Response

The paper reads DSRP correctly as a structural grammar rather than a method, and its rule-to-pattern mapping is the most literal operationalization of the four patterns in a production setting yet published. The clarity gate as a forced distinction and the component map as countable part-whole structure are faithful readings; so is the decision not to tag the serial law and the alignment cycle to single patterns, since both are composites. Two numbers deserve care from anyone citing this work. Zero clarity-gate refusals across 155 features is ambiguous: it is consistent with a gate that shaped how cards were written before they were submitted, and equally consistent with a gate that never bound. And 44 overlap alerts against 85 rework events is suggestive but untested, which the authors say themselves rather than leaving a reader to notice. The honest summary is that this is a well-specified instrument with a first run of data.

**Patterns it shows** D, S, R, P

**Added** 2026-11-10

**How to cite this** Silberman, Dave and Das, Sree Kumar Valath Bhuan (2026). Feature-Controlled Programming: Embedding structural commitments in AI-assisted software development: an industrial case. Journal of Systems Thinking, vol. 6, no. 4 (Academy of Systems Thinking).
