
Inside cfn-lint: Fixing Required-Parameter Schemas, Unknown Comparisons, and SAM Dependency Graphs
An implementation-level deep dive into three merged cfn-lint fixes: E2900 required-set construction, cfnGather uncertainty propagation, and E3004 SAM graph filtering. Includes Python/YAML examples, edge-retention rules, regression matrices, and the open fallback-coverage follow-up.
A linter is most useful when its findings match what the infrastructure actually means. Missing a required parameter can let an incomplete deployment configuration pass. Reporting a circular dependency that disappears after a transform can send a developer debugging the wrong problem. And treating an unavailable resource property as a known value can turn uncertainty into a misleading error.
In this contribution series, we worked on all three problems in cfn-lint , the open-source CloudFormation linter. The work touched parameter-schema construction, cross-resource property comparisons, and the dependency graph used by the circular-dependency rule.
The common goal was straightforward: report errors supported by the template, preserve checks for genuinely invalid configurations, and be explicit about what static analysis cannot determine.
This article walks through the problems, the implementation decisions, and the regression tests. Contribution status is current as of 22 October 2026.
What I Contributed
Contribution | Problem addressed | Status |
|---|---|---|
| PR #4753 | Only the last required deployment parameter was checked | Merged |
| PR #4754 | Unresolved gathered properties caused false SQS and RDS findings | Merged |
| PR #4755 | SAM dependency cycles could be falsely reported or missed | Merged |
| PR #4827 | Missing regression coverage for SAM dependency-graph fallback paths | Open; tests only |
All three fixes merged on 21 October 2026 in IST. The parameter and gathered-property fixes merged on 20 October in UTC; the SAM fix merged on 21 October in UTC.
The implementation boundaries
These fixes operate at three different points in the validation pipeline:
Template parameter declarations + deployment parameter set -> deployment_files/Parameters.py::_build_schema -> required-property validation (E2900)
Resource properties + cross-resource references -> cfnGather + resolve_data_in_schema -> composite-schema evaluation with unknown results -> _validate_gathered -> remapped resource findings
Template references and DependsOn -> Graph(networkx.MultiDiGraph) -> CircularDependency::_dependency_graph -> Graph.get_cycles -> E3004 RuleMatch objectsThe parameter patch changes schema construction. The gathered-property patch changes how unresolved comparison values enter the existing validator. The SAM patch changes the graph supplied to the existing cycle detector. Keeping those boundaries separate made the changes easier to reason about and review.
The code excerpts below are either short extracts from the linked changes or explicitly marked explanatory pseudocode. The graph and schema explanations describe the implementation inspected for this article, rather than claiming a complete formal model of CloudFormation deployment.
1. Checking every required deployment parameter
The first issue was small in code size but important in behavior. When deployment parameter values were supplied to cfn-lint, a template containing multiple parameters without defaults could pass validation even though one was missing. The result depended on parameter declaration order. Issue #4752 captured the asymmetry.
Consider this template:
Parameters: A: Type: String B: Type: StringResources: Topic: Type: AWS::SNS::Topic Properties: TopicName: !Sub '${A}-${B}'Both parameters are required because neither has a default. Before the fix, the reported reproduction behaved differently for these two commands:
cfn-lint template.yaml --parameters B=bcfn-lint template.yaml --parameters A=aSupplying only
B could pass, while supplying only A correctly reported that B was missing. Neither configuration supplied everything the template required.Root cause: replacing a collection instead of accumulating it
The deployment-parameter rule builds a JSON Schema from the template's parameter declarations. While iterating over parameters without defaults, it replaced the required-parameter list:
schema["required"] = [parameter_name]Each assignment discarded the earlier names. After the loop, only the final required parameter remained. We changed the operation to append to the existing list:
schema["required"].append(parameter_name)That one-line change restored the intended behavior: every parameter without a default contributes to the required set.
Testing the behavior, including declaration order
The regression test covers four input combinations: neither parameter supplied, only
A , only B , and both. Each runs in both declaration orders, producing eight cases. A parameter with a default sits between the required parameters to verify that it remains optional.The assertions compare the complete set of missing-parameter messages. This checks both sides of the contract: missing required values are reported, and supplied or defaulted values do not produce those errors. The implementation and tests are in PR #4753 .
The broader lesson is useful beyond CloudFormation: if reordering equivalent input changes validation, inspect how the validator accumulates state.
The invariant behind the one-line patch
Let
P be the valid parameter declarations, R the names whose declarations lack a Default key, and S the names in the supplied deployment parameter set. The presence-validation invariant is:R = {name in P | 'Default' is absent from P[name]}missing = R - SBefore the patch, each loop iteration assigned a singleton list, so the generated schema effectively represented only the last visited member of
R . After the patch, the list accumulates every member. This is a key-presence test, not a truthiness test: an empty-string default is still a declared default.The intended missing-name sets are independent of iteration order:
Supplied names | Expected missing names |
|---|---|
none | A, B |
A | B |
B | A |
A, B | none |
The regression uses
ParameterSet(source=None, parameters=provided) in an evolved validator context, invokes the rule, and compares the set of error messages with the expected set. Reversing the declaration dictionary tests permutation invariance; comparing sets avoids accidentally requiring a particular diagnostic order. This patch concerns presence validation for supplied deployment parameter sets, not a new requirement to supply all values for every template-only lint invocation.2. Preserving uncertainty in cross-resource comparisons
The second problem involved rules that compare properties across resources. For example, cfn-lint checks the compatibility of an SQS source queue and its dead-letter queue. RDS rules also compare instance properties with properties of the referenced cluster.
These checks use
cfnGather to collect values and $data references to compare them. That works when the referenced resource and the relevant property can be resolved from the template. An external resource identified by a literal ARN or name is a different case: its properties may not be available to the linter. Issue #4747 demonstrated false findings for SQS dead-letter queue references and RDS cluster identifiers, as well as a remote property represented by an intrinsic function.
Root cause: comparing a value with an unresolved instruction
Conceptually, a gathered-property schema can contain a comparison like this:
{ "const": {"$data": "/cluster/Engine"}}The
$data object describes where to obtain the comparison value. It is not itself a database engine value. Previously, when lookup failed, the resolver could return that unresolved object. A known local value was then compared against the object rather than against a resolved remote value.This produced false findings from
E3502 , E3707 , and E3709 . Some RDS messages even exposed the unresolved $data object as the expected value.The fix: represent an unknown comparison explicitly
We changed failed lookups to return the internal
_UNRESOLVED sentinel. Schema resolution then marks an unresolved comparison with cfnUnresolved . Deployment-time intrinsic values are also treated as unknown for these comparisons unless the schema explicitly requests literal comparison of the function objects.The important design decision was to preserve that uncertainty through the rest of validation. Simply removing an unresolved constraint would be insufficient. A schema containing
not , if / then , or oneOf could interpret the remaining schema as a definite result and make an incorrect decision.The new keyword yields a validation result marked
unknown=True . The gathered-property validation layer does not emit these unknown results as ordinary findings. This allows the schema machinery to carry uncertainty through composite checks instead of treating missing information as proof of a mismatch. See PR #4754 .This does not verify the actual configuration of an external resource. It avoids claiming a particular incompatibility when the required comparison value is unavailable.
Known values and real mismatches still matter
We added controls to ensure the fix did not silence useful findings:
- A known in-template standard-to-FIFO SQS mismatch still produces the specific queue-type error.
- Known RDS engine and encryption mismatches still produce their respective findings.
- At the schema-resolver boundary, resolved values such as
False,0,None, and an empty string remain known values rather than failed lookups.
- An explicit
cfnContextrequest for literal intrinsic-function comparison remains supported.
- Composite-schema tests cover negation, conditionals, and
oneOfwith unavailable remote values.
The PR records 547 focused tests passing. The central distinction is between a value that is known and false-like, and a value that cannot be resolved. Those are different states, and a validator needs to preserve the difference.
Tracing the resolution failure precisely
At the resolver boundary, these inputs have different meanings:
schema = {"const": {"$data": "/target/value"}}
# A resolved scalar: retain the comparison.resolve_data_in_schema(schema, {"target": {"value": False}})# -> {"const": False}
# An absent property: preserve uncertainty.resolve_data_in_schema(schema, {"target": {}})# -> {"cfnUnresolved": True}
# A deployment-time function object: unknown by default.resolve_data_in_schema( schema, {"target": {"value": {"Ref": "Parameter"}}})# -> {"cfnUnresolved": True}For the
$data path, the resolver traverses dictionaries by key and lists by integer index. Missing keys, invalid indexes or index conversions, and a non-container encountered before the end of the path return _UNRESOLVED . The sentinel is tested with identity ( is ), so an actual resolved False , 0 , None , or empty string is not conflated with lookup failure. The None assertion here is specifically a resolver-unit-test contract; it is not a claim that every resource-property gathering path treats null identically.The critical production branch is:
resolved = resolve_data_reference(v, root_instance)if resolved is _UNRESOLVED: result["cfnUnresolved"] = True continueif not allow_intrinsics and is_function(resolved)[0] is not None: result["cfnUnresolved"] = True continueThis behavior applies to the resolver's supported data-dependent keywords, which include
const , enum , pattern , numeric bounds, and length/item-count constraints. It is not a generic claim that every object-valued schema entry is unresolved.Why dropping the constraint would be incorrect
Consider an unavailable remote value under negation:
{"not": {"const": {"$data": "/remote/value"}}}Deleting the unresolved
const would leave not: {} . The empty schema accepts an instance, so negating it rejects the instance. A missing value would have manufactured a definite failure. Under if , the empty condition could select then ; under oneOf , deleting a constraint could change the number of apparently matching branches.The patch instead registers an internal keyword that yields an unknown result:
def cfnUnresolved(validator, value, instance, schema): yield ValidationError( "Cannot resolve gathered schema value", unknown=True )This connects the unresolved reference to cfn-lint's existing composite-keyword handling. A useful local model is three outcomes: proven match, proven mismatch, and unknown. It is not equivalent to silently making an unknown branch pass.
Composite keyword | Relevant handling in the inspected implementation |
|---|---|
not | An unknown child produces an unknown result instead of being inverted into a definite answer |
if | An unknown condition propagates uncertainty instead of choosing then or else |
oneOf | With an unknown branch and fewer than two known matches, the result remains unknown; two known matches already prove failure |
anyOf | A known matching branch is sufficient; otherwise unknown branches prevent a definite all-branches-failed result |
At the gathered-validation boundary,
if err.unknown: continue suppresses these indeterminate results as user-facing findings. Other errors still follow the existing path-remapping logic, which maps gathered entry/property paths back to template resource properties.The literal-function escape hatch is also explicit. If a
cfnContext sets functions: [] , recursive schema resolution allows structural comparison of an intrinsic object. That preserves checks where comparing two references themselves is intentional, rather than attempting to compare their deployment-time values.3. Evaluating SAM dependency cycles on the right graph
The most involved fix addressed
E3004 , the circular-dependency rule.AWS SAM resources are abstractions over generated CloudFormation resources. A function definition can produce more than one resource, depending on its properties. That means a reference written inside a SAM resource does not always describe a dependency of its underlying Lambda function. AWS documents these mappings in Generated CloudFormation resources for AWS SAM .
Why filtering findings after cycle detection was too late
The previous rule found cycles in the original graph, then skipped reported edges whose source or target was an
AWS::Serverless::* resource.That left two problems:
- A cycle caused by a property that SAM moves to a separate generated resource could still produce a finding on the cycle's non-SAM edges.
- A real cycle between a SAM resource and a native resource could disappear from the findings because both edges touched the SAM resource.
Removing individual findings after discovering a cycle does not establish whether the cycle exists in the dependency model we actually intend to validate.
Three fixtures made the intended behavior concrete
The issue supplied three templates, which became regression fixtures:
Scenario | Earlier behavior reported in the issue | Expected behavior |
|---|---|---|
Function deployment-preference alarms formed an apparent cycle | A non-SAM edge was reported | No E3004 finding for that apparent cycle |
API access-log configuration formed an apparent cycle | A non-SAM edge was reported | No E3004 finding for that apparent cycle |
Function environment referenced a table that depended on the function | The real cycle was missed | Report the circular dependency |
The third case is especially useful because it prevents a false-positive fix from becoming a blanket exemption for SAM templates. Here is the essential reproduction, with descriptive logical IDs:
Transform: AWS::Serverless-2016-10-31Resources: Worker: Type: AWS::Serverless::Function Properties: Runtime: python3.12 Handler: index.handler InlineCode: 'def handler(event, context): return 1' Environment: Variables: TABLE: !Ref DataTable DataTable: Type: AWS::DynamoDB::Table DependsOn: Worker Properties: KeySchema: - AttributeName: pk KeyType: HASH AttributeDefinitions: - AttributeName: pk AttributeType: S BillingMode: PAY_PER_REQUESTThe function needs the table through
Ref . The table explicitly depends on the function. Both dependencies are relevant, so the cycle must remain visible.The fix: prepare the dependency graph before finding cycles
We introduced a separate graph for this rule's analysis. For templates containing SAM resources, the implementation copies the original graph, filters the relevant SAM-originating edges, and runs cycle detection on that graph. Other rules retain access to the original graph and template.
The filtering uses a mapping from supported SAM resource types to their underlying CloudFormation types. Provider schemas identify properties of those underlying resources, and explicit additional properties cover relevant SAM-specific dependencies. For example, a function's environment references and dependencies associated with its generated execution role need to remain represented.
The implementation also handles several details that a broad “ignore SAM” rule would miss:
- Explicit
DependsOnedges are retained.
- Dependencies belonging to separate generated stages, events, or deployment-preference resources are not incorrectly assigned to the SAM logical ID.
- Role-generation properties do not introduce dependencies when an explicit role makes those properties unused for role generation.
- Property lookups are cached by resource type during graph construction.
- Missing schemas and unmapped SAM types take a conservative fallback path.
The merged change is deliberately narrower than running a full SAM transform. It does not add an
aws-sam-translator dependency, and it remains conservative about dependencies contributed solely by generated event resources. That boundary is documented in PR #4755 .The graph model: directed edges with provenance
Graph uses networkx.MultiDiGraph , allowing self-loops and multiple edges between the same pair of resources. In this article, A -> B means that A depends on B . References from Ref , Fn::GetAtt , and Fn::Sub , plus explicit DependsOn , supply dependency edges. Edge metadata includes source_paths , locating the originating expression within the source resource.Provenance is essential because two edges with identical endpoints can have different meanings. A dependency from a function's
Environment must not be treated like a dependency from DeploymentPreference.Alarms merely because both reference the same target.The existing
Graph.get_cycles implementation calls networkx.find_cycle from each resource and deduplicates returned edges. Our patch retains that detector. It does not replace it with a new strongly-connected-components algorithm or claim to enumerate every elementary cycle.Why edge filtering and cycle detection do not commute
Let
G denote the original graph and P(G) the graph after applying the rule's SAM edge policy. The required operation is cycle detection on P(G) , not filtering selected edges out of cycle findings computed on G .The deployment-preference fixture makes the distinction visible:
Original template-reference graph:
Fn --DeploymentPreference.Alarms--> AggregateAggregate --Sub--> ErrorsAlarmErrorsAlarm --Ref--> Fn
Old reporting filter: discover the cycle, then suppress edges touching Fn -> Aggregate -> ErrorsAlarm can still be reported
Graph prepared for E3004: remove the Fn -> Aggregate edge from the SAM base-resource model -> Aggregate -> ErrorsAlarm -> Fn is an acyclic pathThe access-log fixture has the same structure:
Api --AccessLogSetting--> AccessLogGroupAccessLogGroup --DependsOn--> ApiGatewayAccountApiGatewayAccount --DependsOn--> ApiAccessLogSetting belongs to the generated stage rather than the underlying AWS::ApiGateway::RestApi . Removing that outgoing property edge before analysis prevents an apparent base-resource cycle. We do not synthesize the full generated stage in this patch.For the real-cycle fixture, the relevant graph remains:
Worker --Environment.Variables.TABLE / Ref--> DataTableDataTable --DependsOn--> WorkerEnvironment is a property of the underlying Lambda function, and DependsOn is explicit. Both survive filtering, so E3004 reports the cycle.The edge-retention predicate
For each edge originating at a SAM resource, the helper examines its top-level source property and the allowed-property set for that resource type. In explanatory pseudocode:
for source, target, key, metadata in snapshot_of_edges: if source_is_not_sam(source): continue path = metadata.get("source_paths", []) if path == ["DependsOn"]: continue
allowed = cached_properties_for(source_resource_type) remove = ( unused_role_generation_property(source, path) or len(path) < 2 or path[0] != "Properties" or path[1] not in allowed ) if remove: analysis_graph.remove_edge(source, target, key)The explicit edge key matters: a
MultiDiGraph can have several dependencies between the same endpoints. The implementation removes the specific disallowed edge rather than indiscriminately removing the relationship. Iterating over list(graph.graph.edges(keys=True, data=True)) also separates traversal from structural mutation.The allowed set combines the underlying provider schema's property names with these SAM-specific additions:
SAM type suffix | Underlying CloudFormation type | Additional properties in the mapping |
|---|---|---|
Function | AWS::Lambda::Function | CodeUri , ImageUri , Policies , AssumeRolePolicyDocument , PermissionsBoundary , RolePath , Tracing |
Api | AWS::ApiGateway::RestApi | DefinitionBody , DefinitionUri |
HttpApi , WebSocketApi | AWS::ApiGatewayV2::Api | DefinitionBody , DefinitionUri |
Application | AWS::CloudFormation::Stack | Location |
SimpleTable | AWS::DynamoDB::Table | PrimaryKey |
LayerVersion | AWS::Lambda::LayerVersion | ContentUri |
StateMachine | AWS::StepFunctions::StateMachine | DefinitionBody , DefinitionUri , Role , Logging , Tracing , Policies , PermissionsBoundary |
Every suffix in the first column is under
AWS::Serverless:: . The code obtains the provider schema using cfn.regions[0] and caches the property set by SAM type for that helper invocation. This is the implementation's regional scope, not a claim of per-edge or all-region schema analysis.For functions and state machines with an explicit
Role , edges originating from Policies , AssumeRolePolicyDocument , PermissionsBoundary , or RolePath are excluded by the role-specific check. The presence of a Role key determines that branch. Dependencies from an actual explicit role reference are not blanket-suppressed.Isolation and fallback semantics
There are two levels of copying:
graph = copy(original_graph)graph.graph = original_graph.graph.copy()The first creates a separate cfn-lint wrapper; the second creates a separate NetworkX graph structure before edges are removed. This is not a recursive deep copy of every nested metadata value. The helper only reads metadata and removes edges from the copy, so its non-mutation contract is narrower and testable. Templates without SAM resources return the original graph directly without constructing this analysis copy.
When a mapped provider schema is missing,
ResourceNotFoundError is caught and an empty allowed-property set is cached. Because the SAM additions are applied inside the successful lookup path, they are not retained after that exception. An unmapped SAM type also receives an empty set, without querying the provider manager. In both cases, uncertain property-derived edges are removed, while explicit DependsOn edges and edges originating at native resources remain.This fallback can leave some property-driven cycles undetected when schema knowledge is missing. The trade-off is explicit: the rule avoids asserting unsupported dependencies while preserving the dependencies it can justify. It is not a full expansion of SAM or a guarantee that every generated-resource cycle is detectable.
The added preprocessing consists of a graph copy, an edge traversal, and cached schema/property-set construction. That does not imply an end-to-end linear-time bound for E3004: the existing repeated cycle searches and deduplication still determine part of the total cost. No performance benchmark is claimed by these PRs.
Regression tests checked what must remain unchanged
In addition to the three original fixtures, the tests exercise independent cycles between native resources, function environment and execution-role policy dependencies, unused policies with an explicit role, and self-dependencies through
Ref , GetAtt , Sub , and DependsOn .They also assert that the original graph edges and template are unchanged after the rule runs. That matters in a linter where multiple rules inspect shared input: fixing one analysis should not silently alter another rule's view.
The PR records 15 focused tests passing, alongside broader suite validation. The three reported fixtures specifically expect zero E3004 findings for each apparent cycle and two findings for the real two-resource cycle.
4. Following the merged fix with fallback-path tests
The work continued after the SAM fix merged. Its hosted Codecov report showed 91.176% patch coverage, with two uncovered lines and one partially covered line in the new dependency-graph logic.
Those gaps corresponded to meaningful fallback behavior: a missing schema for an underlying resource and an unmapped
AWS::Serverless::* type. We opened PR #4827 to cover those paths. It changes tests only and remains open as of this article's status date.The follow-up adds four parameterized combinations: each fallback path, with and without an explicit
DependsOn . The tests verify that uncertain property dependencies are discarded while explicit dependencies and independent native cycles still produce findings. They also check that failed schema lookups are cached, unmapped types do not trigger a provider-schema lookup, and the original graph object, graph edges, and template remain intact.Validation recorded in the follow-up PR includes 19 focused SAM/circular-dependency tests, plus 3,107 passing unit/integration tests and 28 passing subtests on its stated main-branch baseline. Four data tests retain the repository's default exclusion; a separate data-format test and changed-file checks were also recorded as passing.
The local coverage reconstruction raised fully covered executable lines in the original #4755 patch from 31/34 to 34/34. That is a local result for the original patch, not a claim of 100% project coverage or a hosted Codecov result for the follow-up. Hosted verification was still pending in the PR description.
The four-case fallback regression matrix
The follow-up patches
PROVIDER_SCHEMA_MANAGER.get_resource_schema at the lookup location used by CircularDependency , with a ResourceNotFoundError side effect. It then varies resource type and the presence of an explicit dependency:SAM source type | Explicit Sam -> Target DependsOn | Expected resources with E3004 findings | Schema lookup expectation |
|---|---|---|---|
AWS::Serverless::Function | absent | First, Second | exactly one lookup for the Lambda schema |
AWS::Serverless::Function | present | First, Second, Sam, Target | exactly one lookup for the Lambda schema |
AWS::Serverless::Unknown | absent | First, Second | no lookup |
AWS::Serverless::Unknown | present | First, Second, Sam, Target | no lookup |
First and Second form an independent native-resource cycle in every case. Target always depends on Sam ; adding Sam.DependsOn: Target closes a second, explicit cycle. Sam also has both environment and policy references to Target , so the fixture exercises multiple uncertain property dependencies rather than only one edge.AWS::Serverless::Unknown is a synthetic test type for the fallback path, not a supported SAM resource recommendation. The test invokes the circular-dependency rule directly; it does not assert that the entire synthetic template passes every cfn-lint rule.The assertions check the resource set, the exact match count, the schema mock's call count and arguments, and these non-mutation conditions:
assert cfn.graph is original_graphassert list(original_graph.graph.edges(data=True, keys=True)) == graph_edgesassert template == original_templategraph_edges is deep-copied before execution in the follow-up. That means an accidental change to nested edge metadata cannot be hidden by both the expected and actual lists referring to the same mutated object. The separate template snapshot catches mutation outside the graph.The reported mutation controls deliberately introduced behavior such as re-raising a missing-schema exception, retaining unmapped property edges, or mutating the original graph. The new tests detected those controls. This is evidence that the assertions discriminate between the intended behavior and specific regressions; it is not a claim of exhaustive mutation testing.
For a checkout containing the relevant changes, the focused regression modules can be run from the repository root after following its development setup:
python -m pytest test/unit/rules/deployment_files/test_parameters.pypython -m pytest test/unit/module/jsonschema/test_cfn_gather.py \ test/unit/module/jsonschema/test_keywords_cfn.py \ test/integration/test_gather_references.pypython -m pytest test/integration/test_sam_cycles.pyThe additional four fallback cases require the open #4827 changes. The commands identify the regression modules; they are not a claim that I reran the historical validation suites while writing this article. The suite counts above come from the validation records in the linked PRs, at their respective baselines.
What this contribution process reinforced
These changes had different implementations, but the same discipline helped make them reviewable.
Start with the smallest example that distinguishes correct from incorrect behavior. The parameter issue needed only two required parameters. The SAM issue needed both apparent cycles and a real cycle. Those examples gave the patch a precise target.
Keep a known failure beside every false-positive reproduction. Removing an erroneous SQS finding is only half the job; a known queue-type mismatch must still be detected. The same applies to SAM cycles and RDS comparisons.
Carry uncertainty deliberately. External identifiers, deployment-time intrinsics, and missing schemas are normal inputs for static analysis. Treating them as ordinary concrete values can produce confident but incorrect findings.
Build the right representation before applying the algorithm. For SAM, the important change was the dependency graph supplied to cycle detection. Filtering the resulting messages could not correct the underlying model.
Use coverage gaps to ask behavioral questions. The follow-up was valuable because it tested what happens when schema knowledge is incomplete, not simply because it improved a percentage. Its recorded control checks also verified that the tests catch regressions such as re-raising the missing-schema exception or mutating the original graph.
Thank you to the cfn-lint maintainers and the contributors who provided the issue reports and reproductions. Their work made it possible to turn narrowly described failures into focused fixes and regression tests.
For anyone starting an open-source contribution, a small validation bug is a worthwhile place to begin. A clear reproduction, an explanation of the root cause, and tests that preserve the surrounding behavior can make even a one-line change useful to the next developer who relies on the tool.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article