prol-impact-analysis

What it is for

Use it to see what a change affects, from Prolaborate. You end with what is connected to an element, found one hop at a time, and a report of exactly how far the search went.

prol-impact-analysis traces dependencies and the impact of change in Prolaborate using Analyzer views. An Analyzer view is a saved graph of elements and the relationships between them. The skill seeds a graph from one element, expands it one hop at a time, keeps it readable, and reports what is actually affected.

Capabilities it uses

When to use it, and when not

Use it when the task asks what depends on something, what breaks if an element changes, how two elements are connected, or asks to build or read an Analyzer view. Run prol-start-here first in the session.

Analyzer views are Prolaborate's own objects: created, saved, renamed and deleted in Prolaborate, and identified by an identifier, so renaming one is safe. That is the opposite of a matrix profile, which is authored in EA and keyed by its name.

How it works

1. Run the preflight. (AI Power Tools, AI interprets) Per prol-start-here.

2. Decide what is being promised. AI The AI states which of three deliverables it can give.

   You ask	Delivered
   What directly depends on X	One hop. Complete, and stated as complete
   What breaks if X changes	A bounded traversal. The AI states the depth and the relationship types followed
   Show me everything affected	The AI pushes back, offers a bounded answer and names the bound. An unbounded claim cannot be supported

3. Seed the graph. AI Power Tools One read of an element's traceability returns its neighbors grouped by connector type.

4. Expand the frontier in batches. AI Power Tools One call per frontier returns the connectors of every element in it. The AI de-duplicates on the element identifier (which is both the cycle guard and the revisit guard) and caps the depth itself. The default is two hops, with further expansion only on request.

5. Track why the result is the size it is. AI Power Tools The traversal records whether it stopped at a cap, and how many connectors the follow list discarded. These separate "nothing is connected" from "I stopped looking" and from "my filter matched nothing".

6. Resolve context where useful. AI Power Tools A read of an element's ancestor chain gives context.

7. Report the result with its bounds. AI See "What every answer states".

8. Optionally build an Analyzer view, only when asked. (AI driving the browser, you) Create the view, set the title, place the seed from the Repository Browser, select the node, tick neighbors, add them, save. Reading a graph does not require saving it, so the AI offers the save and does not assume it.

9. Keep the view readable. AI The AI reads the live node and connector counts after each expansion, filters element and connector types with the chips, and sets a directional layout for a dependency story.

What every answer states

The last two lines are the ones people omit, and they make the answer trustworthy. The example figures are illustrative.

Traversal rules

• De-duplicate on the element identifier, always. A dependency graph is not a tree.
• Cap the traversal and report the cap. The stop reason is the difference between "nothing further is affected" and "I stopped looking".
• Count what the filter discarded. That count separates "nothing is connected" from "my follow list matched nothing". A non-zero count with an empty graph means the filter, not the model.
• Filtering by relationship type is a modeling decision. Following Aggregation answers a containment question and following Uses answers a dependency question. Following everything answers neither clearly. The AI says which it followed.
• Base type versus stereotype. Connector data carries both (for example Association and Uses). The traceability panel groups by base type and the filter chips group by stereotype. A filter written against Association and applied to data keyed by Uses silently matches nothing and looks like "nothing is affected". The AI decides which field it matches and says so.
• Direction. Direction fields are not reliable for deciding which end is which (see prol-matrix). For impact analysis the undirected neighborhood is usually what is wanted. If direction matters, the AI says which direction it followed and checks it against the data.
• Edge count is the real budget. A newly reached element brings all its edges to elements already in the set, not only the edge it arrived on. Measured in the Analyzer: the seed placed gave 1 node and 0 connectors; adding 25 one-hop neighbors gave 26 nodes and 25 connectors; adding two more at hop two gave 28 nodes and 63 connectors. Two nodes brought 38 connectors, and a readable star became an unreadable tangle. Hop two is usually the interesting hop, and hop three is usually the one that ruins the picture. The AI reports both counts and stops while the view is still legible.
• Known under-count. The traversal fetches connectors only for the previous frontier, so an edge between two nodes that are both first reached at the final depth is never fetched. Example: depth 1 over edges S-A, S-B and A-B returns three elements and two relationships, although A-B is real. The relationship total is a floor, not a count, so the AI says "at least N relationships" whenever a cap was hit.

Analyzer views in the interface

Analyzers, then Create View opens a canvas in a new tab.

• Name the view before the first Save. Pressing Save on a new view creates it immediately, with no dialog, under the default title Analyzer View. The title is an editable field at the top left. Saving first and renaming after leaves a generically named object on the tenant in the meantime.
• The search box searches the canvas, not the repository. On an empty canvas it returns "No results found" for everything, including elements that plainly exist in the tree beside it. Elements get onto the canvas from the Repository Browser (the folder icon in the left rail), not from search. The AI checks whether the canvas is empty before concluding anything about the repository.
• Selecting a node opens a Traceability panel listing its one-hop neighbors as a three-level tree: element type, connector type, neighbor. Neighbors already on the canvas come back pre-ticked and visually distinct, so the AI can see what is new at this hop. Re-adding does not duplicate.
• The AI ticks neighbors with the group-level checkbox, which cascades to its children. Pressing "Check all" and then Add Selected reported "Select atleast one element to add."
• Filter chips toggle whole element types and connector types off. Turning off the dominant relationship type is usually the fastest way to make a dense view meaningful again. The filter panel shows live node and connector counts.
• Layout is a dropdown with seven options: Top Down, Down Top, Right Left, Left Right, Radial In, Radial Out and Forced Graph (the default). Unlike dashboard tiles, the Analyzer's layout is the AI's to set. Directional layouts read far better than the force-directed default for a dependency story.
• The Save split-button menu holds one item, Save as.

Guardrails on views. A saved view is an object on your tenant, and there is no undo; baselines are an EA mechanism and do not reach Prolaborate's own objects. The AI asks before creating one. It never deletes a view this session did not create, because it cannot tell whose a view is or who relies on it. "Tidy up the Analyzers list" is not authorization to remove someone else's saved work, so the AI lists what is there and asks. The same applies to editing someone else's view.

Reading through structured data

The AI reads through Prolaborate's structured data and acts through the interface.

What you get

• An answer that names the seed, the depth reached, the relationship types followed, what was found, whether a cap was hit, whether a filter discarded anything, and the identity it was read as.
• On request, a saved Analyzer view, titled before it was saved, laid out directionally.
• A plain statement that a multi-hop result is bounded, with the relationship total phrased as a floor when a cap was hit.

Tools it relies on

• Browser control, to drive the Analyzers page and canvas: Create View, the Repository Browser, the Traceability panel, filter chips, layout and Save
• Prolaborate's traceability, connector, related-element, ancestor and view-list reads
• The traversal routine in the skill: a breadth-first search with a depth cap, a node cap, de-duplication, and the stop reason and filtered-count it reports
• The preflight in prol-start-here

No server operation is used. For the same question against the EA model itself, see Graph and traceability.

Sample prompts

1. One hop, stated as complete.

2. A bounded traversal (default two hops), stating depth, relationship types, counts, and whether a cap or filter shaped the result.

3. Pushes back on "everything", offers a bounded answer and names the bound.

4. Traverses from one toward the other and reports the path and its length, or says no path was found within the cap.

5. Sets the title before saving, builds the view from the Repository Browser, uses a directional layout, and reads the counts after each expansion.

6. Lists what exists and asks. It deletes nothing it did not create.

The application names are illustrations. Replace them with your own.

Recommended models

Ratings are guidance based on the kind of reasoning the skill needs, not measured benchmarks.

Checking accuracy and completeness

1. Bounds stated. Every multi-hop answer names the seed, depth reached, relationship types followed, whether a cap was hit, and whether a filter discarded anything. Red flag: "this is the blast radius" or "everything affected".
2. One-hop check against the screen. For a seed, open the Traceability panel in the Analyzer and compare its one-hop neighbor list with the AI's seed read. They should agree.
3. Cap versus empty. On a seed with known neighbors, run with depth 1 and depth 2 and confirm that the stop reason is reported when the frontier is not empty. Red flag: a capped result reported as if the frontier were empty. A claim of "not connected" after a capped search is a failure.
4. Filter matched. Run with a follow list of Uses, then with Association. The AI must state which field was matched. Red flag: a filter on Association against stereotype-keyed data returns nothing and is reported as "nothing is affected". A non-zero filtered count with an empty graph means the filter, not the model.
5. Edge count reported. After an expansion in a dense area, both node and connector counts are reported, and the AI warns before expanding again. Red flag: node count alone as the measure of size.
6. Relationship total phrased as a floor whenever a cap was hit ("at least N").
7. Cycle handling. On a graph with a back-reference or cycle, the traversal terminates and elements are not double-counted.
8. View hygiene. The view title is set before the first Save, no view is created unasked, and after any delete the list is re-read to confirm. Verify that nothing named Analyzer View is left on the tenant. If a view has to be left behind, the AI tells you which one and why it is still there.
9. Identity stated. The report names the identity it was read as and says a restricted user may see a smaller graph.

The skill ships 22 acceptance cases. An empty or small result has several causes (nothing there, a cap, a filter that matched nothing, a permissions boundary), and a passing run says why the result is the size it is.

Limitations

• Prolaborate reads are one hop. Any multi-hop result is composed by the AI with its own cap, and the relationship total is a floor when a cap was hit.
• One identity. Verified as a Super Admin, which short-circuits authorization. The traceability panel reaches across packages, so a restricted user may see a smaller graph.
• The AI says neither that a saved view is private nor that it is shared. No sharing control was found.
• The traversal handles cycles by design. De-duplication was confirmed on a direct back-reference.
• One neighbor lookup carries an API rate limit, and a second call shares its contract with different rate limiting.
• The AI never writes through the diagram service, because that service serves both Analyzer views and Prolaborate diagrams.
• Dependency questions against the EA model itself are answered by the ea_analyze operations (Trace dependencies).

See also Limitations and known issues.