Use Behavioral Mapping and User Path prompts when MIRENA needs to understand how users should move through a page, cluster, draft, internal link plan, SERP block, or schema cue.
This workflow looks at user state, journey stage, friction, trust, effort, path priority, proof needs, comparison needs, support needs, CTA timing, and satisfaction signals.
Start with source context.
Do not run behavioral prompts against a loose page, draft, sitemap, CTA, analytics export, behavior report, or schema plan until MIRENA knows the site, offer, audience, allowed topics, blocked topics, page roles, internal link rules, and next workflow stage.
Use the source context template before this workflow if the project base is not ready. Use Getting Started with MIRENA if you need the full onboarding route first.
Start with Source Context Before Behavioral Mapping
Source context controls the behavioral layer.
It tells MIRENA what the site is, who it serves, what it sells, which topics belong, which topics are blocked, which pages already exist, which internal routes matter for the product path, and which workflow should come next.
A behavioral workflow can create weak recommendations if it starts from analytics, CTAs, links, or heatmaps alone. A click path can look popular but still be wrong for the source context. A CTA can look visible but still appear too early. A support page can get visits but still fail to move users forward.
The Source Context page explains how source context protects the site’s topical focus before new pages or paths enter the system.
Use source context to define:
- site purpose
- audience
- offer
- region
- allowed topics
- blocked topics
- page roles
- protected pages
- existing conversion routes
- support routes
- proof routes
- comparison routes
- internal link targets
- workflow goal
- output format
- next workflow stage
When source context is missing, stop and build it first.
What Behavioral Mapping and User Path Workflows Do
Behavioral Mapping and User Path Workflows turn a semantically structured site into a user-useful journey system.
They do not collect raw discovery evidence.
They do not build the topical map.
They do not replace entity SEO.
They do not write final schema.
They decide what the user likely needs next.
The output can feed Content Briefs when a new page needs user path instructions. It can feed Drafting + Rewriting when a draft needs clearer passage order, proof placement, CTAs, links, or support blocks. It can feed semantic internal linking when pages need better route planning. It can feed information gain work when a page adds semantic novelty but does not yet help users enough.
Use MIRENA outputs when you need to define what the behavioral package should return.
A strong behavioral output should tell the team:
- what state the user is likely in
- where the page sits in the journey
- where the user may get stuck
- what proof the user needs
- how hard the page feels
- which passage should come earlier
- which link should guide the next step
- which CTA is too early, weak, or unclear
- which support route is missing
- which fallback route is needed
- which behavior signals should be monitored
- which changes need testing
- which risks should block release
What This Page Does Not Repeat
This page does not repeat Raw Semantic Discovery prompts.
Raw Semantic Discovery collects candidates, modifiers, query paths, SERP patterns, competitor signals, and opportunity notes.
This page starts after that evidence exists.
This page does not repeat Topical Maps + Planning prompts. Topical Mapping and Site Architecture decides pages, roles, hierarchy, and publishing order.
This page also does not repeat Entity SEO prompts. Entity SEO handles entity meaning, salience, placement, relationships, and markup cues.
Behavioral Mapping and User Path Workflows use those outputs as evidence, then decide how users should move through the site.
Use this page when the job is user state, journey stage, friction, trust, effort, next step, fallback path, path weighting, behavioral internal links, user gain, satisfaction, feedback, testing, monitoring, or publish readiness.
Use Semantic SEO when the page also needs stronger meaning, context, and topic fit.
When to Use Behavioral Mapping and User Path Prompts
Use this prompt collection when you need to turn a structured page or map into a user path.
Behavioral Mapping and User Path Workflows are useful for:
- user state classification
- journey stage mapping
- user journey planning
- search journey routing
- friction point extraction
- friction repair
- trust requirement mapping
- proof path planning
- comparison path planning
- conversion path planning
- support path planning
- effort scoring
- effort reduction
- next best path planning
- fallback path planning
- behavioral internal links
- anchor intent alignment
- CTA friction review
- dead-end page repair
- no next step repair
- user gain scoring
- UX content component planning
- behavioral SERP validation
- behavioral schema adaptation
- behavior data review
- satisfaction signal ingest
- feedback loops
- experiment planning
- publish readiness
- post-publish monitoring
Use MIRENA inputs when you need to decide which files should feed this workflow. Use the MIRENA workflow when the behavioral output needs a clear route into briefing, rewriting, internal linking, information gain, SERP feature planning, schema notes, testing, or monitoring.
The Behavioral Mapping Workflow
Run the Behavioral Mapping and User Path workflow in this order.
- Set the behavioral scope.
- Define the behavioral goal.
- Classify user state.
- Map journey stage.
- Map the user journey.
- Map search journey routes.
- Annotate behavioral nodes.
- Weight behavioral edges.
- Classify passage roles.
- Review passage order.
- Extract friction points.
- Plan friction repairs.
- Map trust requirements.
- Plan trust paths.
- Plan proof paths.
- Plan comparison paths.
- Plan conversion paths.
- Plan support paths.
- Score effort.
- Plan effort reduction.
- Recommend next best paths.
- Plan fallback paths.
- Plan behavioral internal links.
- Align anchor intent.
- Repair dead-end pages.
- Repair missing next steps.
- Review CTA friction.
- Score information gain and user gain.
- Compare semantic completeness with user usefulness.
- Recommend UX content components.
- Validate SERP blocks from a user path angle.
- Adapt schema cues to visible user value.
- Review behavior data.
- Ingest satisfaction signals.
- Run the behavioral feedback loop.
- Plan experiments.
- Validate behavioral changes.
- Audit behavioral compliance.
- Check publish readiness.
- Plan monitoring.
- Hand off dashboard status.
- Hand off behavioral findings.
Do not move into publishing, schema deployment, link implementation, CTA changes, or experiments if user path, proof, trust, effort, privacy, compliance, or rollback risks are unresolved.
The Behavioral Mapping Prompt Pattern
Use short commands when the task is clear.
Use expanded prompts when the page needs fields, evidence, scoring, decisions, risk flags, owner actions, validation rules, and workflow routing.
Short command pattern:
text
Run [behavioral module] on [asset].Expanded prompt pattern:
text
Run [behavioral module] on [asset].
Use the source context first.
Use the topical map, draft, page inventory, internal link plan, SERP plan, schema cues, analytics notes, or behavior data only as evidence.
Do not recommend a path, CTA, proof block, link, experiment, or schema cue that lacks visible user value.
Return the output with these fields:
- page or node
- user state
- journey stage
- friction point
- trust requirement
- effort driver
- recommended path
- fallback path
- internal link direction
- evidence source
- risk note
- next workflow route
Flag anything that should be revised, tested, monitored, suppressed, or blocked.
Route the final output into Content Briefs, Drafting and Rewriting, Semantic Internal Linking, Information Gain, SERP Feature Planning, Schema Cues after approval, Testing, or Publish Readiness.A short prompt is enough for a simple behavioral task.
An expanded prompt is better when the input is large, messy, risky, or ready for handoff.
What to Give MIRENA Before Running Behavioral Mapping
Start with source context.
Then add the strongest evidence available.
For a page review, give MIRENA:
- source context
- page URL or draft
- page role
- target user
- journey stage if known
- target next step
- internal link targets
- proof assets if available
- CTA goal
- known friction points
For a cluster review, give MIRENA:
- source context
- approved topical map
- page inventory
- page roles
- internal link plan
- content briefs if available
- known user paths
- support pages
- proof pages
- conversion pages
- comparison pages
For a draft review, give MIRENA:
- source context
- full draft
- page role
- target user state
- target journey stage
- planned internal links
- planned CTA
- proof assets
- FAQ or table blocks
- schema cues if approved
For analytics and behavior data, give MIRENA:
- source context
- GSC page data
- GSC query data
- GA4 landing page data
- GA4 engagement notes
- scroll depth notes
- click tracking notes
- heatmap notes
- session recording notes
- internal search notes
- support logs or CRM notes if privacy safe
For post-publish review, give MIRENA:
- source context
- page or cluster target
- monitoring window
- traffic source notes
- satisfaction signals
- CTA data
- link click data
- support outcomes
- conversion path notes
- experiment notes if any
Use anchor text by intent when anchor wording is part of the behavioral review. Use rewrite for internal links when the draft needs copy changes to support new user paths.
Behavioral Mapping and User Path Modules
The modules below add user state, journey stage, friction, trust, effort, path priority, satisfaction, feedback, testing, and publish readiness to MIRENA workflows.
Choose the smallest module that fits the job.
1. Behavioral Map Scope
Use this to define the boundary of the behavioral review.
Short command:
text
Run Behavioral Map Scope on this project.Expanded prompt:
text
Run Behavioral Map Scope on this project.
Use the source context first.
Define the behavioral scope before user states, paths, CTAs, links, or components are changed.
Return the output with these fields:
- site or section being reviewed
- pages included
- pages excluded
- target audience
- key user states
- key journey stages
- conversion routes
- support routes
- proof routes
- behavior data available
- behavior data missing
- next workflow route
Reject behavioral recommendations that do not fit the source context.
Flag missing inputs before the workflow continues.
Route the output into Behavioral Map Goal or User State Classification.Best for:
- new behavioral reviews
- cluster path reviews
- site audits
- conversion path planning
- behavior data projects
Output should include:
- scope boundary
- included pages
- excluded pages
- audience
- key user states
- available data
- missing data
- next route
Use this to:
Keep behavioral work focused on the right pages, users, and paths.
Behavioral Map Scope stops MIRENA from changing links, CTAs, or paths without a clear boundary.
2. Behavioral Map Goal
Use this to define the job of the behavioral workflow.
Short command:
text
Run Behavioral Map Goal for this project.Expanded prompt:
text
Run Behavioral Map Goal for this project.
Use the source context first.
Choose one primary goal:
- reduce user effort
- repair dead ends
- improve trust paths
- improve support paths
- improve comparison paths
- improve conversion paths
- improve internal link routing
- improve passage order
- validate SERP blocks
- validate schema cues
- plan experiments
- monitor satisfaction
Return the output with these fields:
- primary behavioral goal
- secondary goals
- target pages
- target user states
- target journey stages
- evidence needed
- success signals
- risk notes
- next workflow route
Do not combine too many goals in one pass.
Route the output into User State Classification, Friction Point Extraction, or Next Best Path.Best for:
- unclear behavioral tasks
- link path planning
- CTA repair
- trust improvement
- post-publish review
Output should include:
- primary goal
- target pages
- user states
- journey stages
- success signals
- next route
Use this to:
Stop the behavioral workflow from becoming too broad.
A friction repair pass needs a different output than a trust path pass or publish readiness pass.
3. User State Classification
Use this to classify the likely user state for a page, cluster, or query path.
Short command:
text
Run User State Classification on this page.Expanded prompt:
text
Run User State Classification on this page.
Use the source context first.
Classify the likely user state for the page, passage, query group, or cluster.
Return the output with these fields:
- page or node
- likely user state
- secondary user state
- confidence
- evidence source
- intent signal
- behavior signal
- risk note
- content need
- path need
- next workflow route
Use states such as beginner, researcher, comparer, skeptical user, low confidence user, ready to act, high urgency user, returning user, post purchase user, or blocked user.
Flag pages that need different routes for different states.
Route the output into Journey Stage Mapping, Friction Point Extraction, or Next Best Path.Best for:
- page reviews
- drafts
- query groups
- support pages
- conversion pages
Output should include:
- likely user state
- secondary user state
- confidence
- content need
- path need
- next route
Use this to:
Make paths fit the person using the page.
A beginner, comparer, skeptical user, and ready to act user should not always get the same next step.
4. Journey Stage Mapping
Use this to map where the page sits in the user journey.
Short command:
text
Run Journey Stage Mapping on this page set.Expanded prompt:
text
Run Journey Stage Mapping on this page set.
Use the source context first.
Assign a journey stage to each page, passage, path, CTA, support route, proof block, and comparison block.
Return the output with these fields:
- page or node
- journey stage
- stage reason
- user state fit
- content role
- next step need
- proof need
- support need
- risk note
- next workflow route
Use stages such as awareness, education, selection, comparison, trust check, conversion, onboarding, support, retention, and advocacy.
Flag pages with mixed or conflicting journey stages.
Route the output into User Journey Map, Passage Role Classification, or Next Best Path.Best for:
- clusters
- landing pages
- content refresh
- product paths
- docs and support pages
Output should include:
- journey stage
- stage reason
- user state fit
- proof need
- next route
Use this to:
Place each page in the right journey step before links or CTAs are changed.
Journey stage controls timing, proof, CTA placement, and next step.
5. User Journey Map
Use this to connect pages into a journey.
Short command:
text
Run User Journey Map on this cluster.Expanded prompt:
text
Run User Journey Map on this cluster.
Use the source context first.
Map the user journey across the cluster.
Return the output with these fields:
- starting page
- journey stage
- user state
- next page
- proof path
- comparison path
- support path
- conversion path
- fallback path
- friction risk
- next workflow route
Do not force every journey toward conversion.
Match the path to the user state and journey stage.
Route the output into Next Best Path, Behavioral Internal Linking, or Conversion Path Planning.Best for:
- cluster planning
- internal link planning
- product paths
- support paths
- conversion routes
Output should include:
- starting page
- journey stage
- next page
- fallback path
- friction risk
- next route
Use this to:
Show how people should move through the site.
A journey map makes pages work together instead of acting as isolated entries.
6. Search Journey Mapping
Use this to connect search behavior to site paths.
Short command:
text
Run Search Journey Mapping on this query group.Expanded prompt:
text
Run Search Journey Mapping on this query group.
Use the source context first.
Map search queries to user states, journey stages, page roles, and next site paths.
Return the output with these fields:
- query
- likely user state
- journey stage
- current page
- next needed answer
- next page target
- support route
- proof route
- conversion route
- content gap
- next workflow route
Flag queries where the page satisfies the search but leaves no next step.
Route the output into Content Briefs, Drafting and Rewriting, or Behavioral Internal Linking.Best for:
- GSC query data
- landing pages
- content briefs
- search journey planning
- internal link planning
Output should include:
- query
- likely user state
- next needed answer
- next page target
- content gap
- next route
Use this to:
Connect search intent to the path users need after the landing page.
A page can answer a query and still fail if users do not know where to go next.
7. Behavioral Node Annotation
Use this to add behavioral fields to pages or topical nodes.
Short command:
text
Run Behavioral Node Annotation on this map.Expanded prompt:
text
Run Behavioral Node Annotation on this map.
Use the source context first.
Annotate every page or topical node with user path fields.
Return the output with these fields:
- page or node
- user state
- journey stage
- content role
- friction profile
- trust requirement
- effort score
- satisfaction signal if available
- recommended action
- next workflow route
Do not change page structure yet.
Route the output into Behavioral Edge Weighting or Friction Point Extraction.Best for:
- approved topical maps
- page inventories
- cluster reviews
- internal link planning
- behavioral overlays
Output should include:
- page or node
- user state
- journey stage
- friction profile
- trust requirement
- next route
Use this to:
Turn a topical map into a behavioral map.
Behavioral Node Annotation adds user path data to existing page structure.
8. Behavioral Edge Weighting
Use this to score paths between pages.
Short command:
text
Run Behavioral Edge Weighting on this map.Expanded prompt:
text
Run Behavioral Edge Weighting on this map.
Use the source context first.
Score every page-to-page path by semantic fit and user usefulness.
Return the output with these fields:
- source page
- target page
- edge role
- semantic weight
- behavioral weight
- user state fit
- journey fit
- friction reduction value
- trust support value
- effort reduction value
- final path priority
- recommended anchor direction
- next workflow route
Promote paths that help the user progress.
Suppress paths that are topically related but weak for the user’s current need.
Route the output into Next Best Path, Behavioral Internal Linking, or Anchor Intent Alignment.Best for:
- internal link plans
- cluster routes
- hub and spoke paths
- docs navigation
- conversion paths
Output should include:
- source page
- target page
- semantic weight
- behavioral weight
- final path priority
- next route
Use this to:
Weight paths by usefulness instead of topical closeness alone.
A link can be semantically related and still be a poor next step.
9. Passage Role Classification
Use this to identify what each passage should do.
Short command:
text
Run Passage Role Classification on this draft.Expanded prompt:
text
Run Passage Role Classification on this draft.
Use the source context first.
Classify the role of each passage, block, answer, FAQ, table, CTA, proof block, or support block.
Return the output with these fields:
- passage
- current role
- intended role
- role match score
- role conflict
- user state fit
- journey stage fit
- trust support score
- effort reduction score
- rewrite need
- next workflow route
Flag passages that perform the wrong job.
Route the output into Passage Order Review, Drafting and Rewriting, or UX Content Component Recommendation.Best for:
- drafts
- rewrites
- briefs
- support pages
- comparison pages
Output should include:
- passage
- current role
- intended role
- role conflict
- rewrite need
- next route
Use this to:
Make each section do one clear job for the user.
Passage role checks help a page avoid mixing explanation, proof, comparison, and CTA pressure in the wrong places.
10. Passage Order Review
Use this when the page has the right blocks in the wrong order.
Short command:
text
Run Passage Order Review on this draft.Expanded prompt:
text
Run Passage Order Review on this draft.
Use the source context first.
Review the order of sections, passages, summaries, proof blocks, CTAs, FAQs, tables, and internal links.
Return the output with these fields:
- current section
- current position
- recommended position
- user state reason
- journey stage reason
- friction reduced
- trust need supported
- effort reduced
- risk note
- next workflow route
Do not rewrite the copy.
Route the output into Drafting and Rewriting, Content Briefs, or UX Content Component Recommendation.Best for:
- long drafts
- comparison pages
- product pages
- docs pages
- conversion pages
Output should include:
- current section
- recommended position
- user state reason
- journey stage reason
- next route
Use this to:
Put answers, proof, links, and CTAs in the order users need.
The right block in the wrong place can still create friction.
11. Friction Point Extraction
Use this to find user blockers.
Short command:
text
Run Friction Point Extraction on this page.Expanded prompt:
text
Run Friction Point Extraction on this page.
Use the source context first.
Find barriers that slow, confuse, discourage, misroute, or stop the user from taking the next useful step.
Return the output with these fields:
- page or passage
- friction point
- friction type
- severity
- affected user state
- affected journey stage
- evidence source
- recommended action
- owner workflow
- next workflow route
Classify friction as clarity, trust, effort, price, proof, choice overload, navigation, support, timing, technical complexity, accessibility, or CTA friction.
Route the output into Friction Repair Planning, Trust Requirement Mapping, or Effort Score.Best for:
- weak landing pages
- product pages
- support pages
- draft reviews
- conversion paths
Output should include:
- friction point
- friction type
- severity
- affected user state
- next route
Use this to:
Find what blocks progress before MIRENA changes paths or CTAs.
Friction extraction gives the repair workflow a clear target.
12. Friction Repair Planning
Use this to turn friction findings into fixes.
Short command:
text
Run Friction Repair Planning on this friction list.Expanded prompt:
text
Run Friction Repair Planning on this friction list.
Use the source context first.
Turn friction records into action-ready fixes.
Return the output with these fields:
- friction point
- affected page
- affected user state
- affected journey stage
- recommended fix
- content fix
- link fix
- proof fix
- UX component fix
- test or monitor note
- next workflow route
Do not apply fixes without routing them.
Route the output into Drafting and Rewriting, Behavioral Internal Linking, UX Content Component Recommendation, or Testing.Best for:
- friction audits
- UX content repair
- rewrite plans
- internal link updates
- CTA repair
Output should include:
- friction point
- recommended fix
- content fix
- link fix
- proof fix
- next route
Use this to:
Move from diagnosis into action.
Friction Repair Planning turns blockers into copy, link, proof, component, or testing tasks.
13. Trust Requirement Mapping
Use this to identify proof needs.
Short command:
text
Run Trust Requirement Mapping on this page.Expanded prompt:
text
Run Trust Requirement Mapping on this page.
Use the source context first.
Identify the proof, reassurance, transparency, evidence, methodology, review, author, policy, guarantee, pricing, or local proof needed for the user to continue.
Return the output with these fields:
- page or passage
- trust requirement
- trust gap
- proof needed
- evidence source
- user state
- journey stage
- content placement
- internal link direction
- next workflow route
Flag claims that need stronger evidence.
Route the output into Trust Path Planning, Proof Path Planning, Content Briefs, or Drafting and Rewriting.Best for:
- commercial pages
- comparison pages
- service pages
- pricing paths
- trust repair
Output should include:
- trust requirement
- trust gap
- proof needed
- content placement
- next route
Use this to:
Make trust a structural requirement, not a copy add-on.
Trust needs should guide proof placement, link paths, and CTA timing.
14. Trust Path Planning
Use this to route users toward proof.
Short command:
text
Run Trust Path Planning on this cluster.Expanded prompt:
text
Run Trust Path Planning on this cluster.
Use the source context first.
Plan routes that help skeptical, comparing, low confidence, or ready to act users find proof.
Return the output with these fields:
- source page
- trust need
- proof page or proof block
- route type
- anchor direction
- placement
- user state
- journey stage
- risk note
- next workflow route
Do not promote a conversion route before trust gaps are reduced.
Route the output into Behavioral Internal Linking, Proof Path Planning, or Conversion Path Planning.Best for:
- buyer journeys
- comparison paths
- trust repair
- proof pages
- conversion paths
Output should include:
- source page
- trust need
- proof page or block
- anchor direction
- next route
Use this to:
Create paths that build confidence before action.
A trust path helps users verify before they convert.
15. Proof Path Planning
Use this when users need evidence before they continue.
Short command:
text
Run Proof Path Planning on this page.Expanded prompt:
text
Run Proof Path Planning on this page.
Use the source context first.
Identify proof blocks, proof pages, examples, case notes, screenshots, reviews, methodology notes, comparison evidence, or guarantee support needed for the path.
Return the output with these fields:
- page
- proof need
- proof asset
- proof placement
- proof route
- anchor direction
- user state
- journey stage
- next workflow route
Flag proof needs that lack evidence.
Route the output into Content Briefs, Drafting and Rewriting, or Behavioral Internal Linking.Best for:
- product pages
- comparison pages
- service pages
- use case pages
- ready to act users
Output should include:
- proof need
- proof asset
- placement
- route
- next route
Use this to:
Help users verify claims before they move forward.
Proof paths should support trust and reduce risk.
16. Comparison Path Planning
Use this when users are choosing between options.
Short command:
text
Run Comparison Path Planning on this cluster.Expanded prompt:
text
Run Comparison Path Planning on this cluster.
Use the source context first.
Plan paths for users comparing products, services, methods, tools, vendors, prices, or workflows.
Return the output with these fields:
- source page
- comparison need
- comparison target
- comparison block
- table need
- proof need
- internal link direction
- CTA timing
- next workflow route
Flag pages where comparison support is missing.
Route the output into Content Briefs, Information Gain, or Behavioral Internal Linking.Best for:
- alternatives pages
- product comparison pages
- method comparisons
- buyer guides
- commercial investigation paths
Output should include:
- comparison need
- comparison target
- table need
- proof need
- next route
Use this to:
Support decision clarity without forcing early conversion.
Comparison paths help users choose with less uncertainty.
17. Conversion Path Planning
Use this when users are ready to act.
Short command:
text
Run Conversion Path Planning on this map.Expanded prompt:
text
Run Conversion Path Planning on this map.
Use the source context first.
Plan routes from education, comparison, proof, docs, and use case pages into conversion pages.
Return the output with these fields:
- source page
- conversion target
- buyer stage
- readiness signal
- trust gap
- effort risk
- CTA placement
- fallback path
- measurement note
- next workflow route
Do not push conversion when trust or effort blocks are high.
Route the output into Drafting and Rewriting, Behavioral Internal Linking, or CTA Friction Review.Best for:
- product led pages
- service pages
- use case pages
- comparison pages
- pricing paths
Output should include:
- source page
- conversion target
- readiness signal
- trust gap
- fallback path
- next route
Use this to:
Route action only when the page has prepared the user.
Conversion paths should follow readiness, not pressure.
18. Support Path Planning
Use this when users need help, setup, or troubleshooting.
Short command:
text
Run Support Path Planning on this docs cluster.Expanded prompt:
text
Run Support Path Planning on this docs cluster.
Use the source context first.
Plan support routes across setup, troubleshooting, usage, outputs, handoffs, FAQs, templates, and fallback pages.
Return the output with these fields:
- support page
- support task
- current user state
- next support step
- fallback path
- proof or policy need
- link direction
- support success signal
- next workflow route
Flag support pages with no next step.
Route the output into Docs Briefs, Drafting and Rewriting, or Behavioral Internal Linking.Best for:
- docs clusters
- onboarding flows
- support centers
- troubleshooting pages
- product workflows
Output should include:
- support page
- support task
- next support step
- fallback path
- next route
Use this to:
Help users complete tasks without searching again.
Support paths should reduce abandonment and confusion.
19. Effort Score
Use this to score how hard a page or path feels.
Short command:
text
Run Effort Score on this page.Expanded prompt:
text
Run Effort Score on this page.
Use the source context first.
Score the user effort needed to understand, trust, compare, choose, convert, troubleshoot, or continue.
Return the output with these fields:
- page or passage
- effort score
- effort drivers
- affected user state
- affected journey stage
- high effort block
- recommended reduction
- owner workflow
- confidence
- next workflow route
Consider reading load, missing summary, weak next step, trust gap, price uncertainty, dense passages, poor link paths, missing proof, unclear CTA, technical complexity, and accessibility risk.
Route the output into Effort Reduction Plan, Drafting and Rewriting, or UX Content Component Recommendation.Best for:
- long pages
- technical pages
- docs
- comparison pages
- conversion pages
Output should include:
- effort score
- effort drivers
- high effort block
- recommended reduction
- next route
Use this to:
Find where the user is doing too much work.
Effort Score helps MIRENA reduce load without removing useful depth.
20. Effort Reduction Plan
Use this to reduce effort without weakening meaning.
Short command:
text
Run Effort Reduction Plan on this effort score.Expanded prompt:
text
Run Effort Reduction Plan on this effort score.
Use the source context first.
Turn effort drivers into specific page, passage, link, component, proof, and CTA fixes.
Return the output with these fields:
- page or passage
- effort driver
- severity
- recommended reduction
- section change
- link change
- component change
- proof change
- test or monitor note
- next workflow route
Do not remove useful depth only to make the page shorter.
Route the output into Drafting and Rewriting, UX Content Component Recommendation, or Behavioral Internal Linking.Best for:
- page repair
- rewrite planning
- docs improvement
- support paths
- user experience review
Output should include:
- effort driver
- severity
- section change
- component change
- next route
Use this to:
Lower user effort while preserving semantic strength.
Effort reduction should make the page easier to use, not thinner.
21. Next Best Path
Use this to decide the strongest next step.
Short command:
text
Run Next Best Path on this page.Expanded prompt:
text
Run Next Best Path on this page.
Use the source context first.
Recommend the next most useful page, block, answer, CTA, proof route, comparison route, support route, or fallback route for the user.
Return the output with these fields:
- source page
- current user state
- current journey stage
- next best path
- path type
- reason
- anchor direction
- placement
- fallback path
- measurement note
- next workflow route
Do not recommend the nearest topical page if it does not help the user continue.
Route the output into Behavioral Internal Linking, Drafting and Rewriting, or Map Handoff.Best for:
- landing pages
- blog posts
- docs pages
- hub pages
- conversion routes
Output should include:
- source page
- next best path
- path type
- anchor direction
- fallback path
- next route
Use this to:
Give each page a clear next step.
Next Best Path turns a page from an answer into a journey point.
22. Fallback Path Planning
Use this when the primary path may fail.
Short command:
text
Run Fallback Path Planning on this page.Expanded prompt:
text
Run Fallback Path Planning on this page.
Use the source context first.
Plan fallback routes for users who are not ready, are blocked, need proof, need support, need comparison, or need a simpler answer.
Return the output with these fields:
- page
- primary path
- fallback path
- user state served
- journey stage served
- friction reduced
- trust supported
- link placement
- risk note
- next workflow route
Flag pages with no fallback.
Route the output into Behavioral Internal Linking or Drafting and Rewriting.Best for:
- conversion pages
- support pages
- comparison pages
- pricing paths
- long guides
Output should include:
- primary path
- fallback path
- user state served
- trust supported
- next route
Use this to:
Stop the page from becoming a dead end.
Fallback paths support users who are not ready for the primary action.
23. Behavioral Internal Linking
Use this to make internal links support the user path.
Short command:
text
Run Behavioral Internal Linking on this cluster.Expanded prompt:
text
Run Behavioral Internal Linking on this cluster.
Use the source context first.
Plan internal links based on user state, journey stage, friction, trust, effort, path priority, and semantic relationship.
Return the output with these fields:
- source page
- target page
- path role
- anchor direction
- placement
- user state fit
- journey fit
- friction reduced
- trust supported
- effort reduced
- priority
- next workflow route
Do not add generic links.
Route the output into Semantic Internal Linking, Drafting and Rewriting, or Anchor Intent Alignment.Best for:
- cluster link plans
- hub and spoke links
- support paths
- conversion paths
- rewrite tasks
Output should include:
- source page
- target page
- path role
- anchor direction
- placement
- priority
Use this to:
Make links serve the next useful step.
Use semantic internal linking when the route also needs cluster, entity, and architecture support.
24. Anchor Intent Alignment
Use this when anchor text should match the user’s next action.
Short command:
text
Run Anchor Intent Alignment on this link plan.Expanded prompt:
text
Run Anchor Intent Alignment on this link plan.
Use the source context first.
Review anchor text for user state, journey stage, path role, surrounding context, and target page promise.
Return the output with these fields:
- source page
- target page
- current anchor
- recommended anchor direction
- anchor intent
- surrounding passage
- user state fit
- journey fit
- risk note
- next workflow route
Flag anchors that overpromise, underdescribe, repeat too often, or fail the next step.
Route the output into Drafting and Rewriting or Semantic Internal Linking.Best for:
- internal link rewrites
- page refresh
- anchor systems
- hub links
- support links
Output should include:
- source page
- target page
- current anchor
- recommended anchor direction
- next route
Use this to:
Make anchor text describe the next logical step.
Use anchor text by intent when the anchor system needs more detail.
25. Dead-End Page Repair
Use this when pages leave users with no path.
Short command:
text
Run Dead-End Page Repair on this page set.Expanded prompt:
text
Run Dead-End Page Repair on this page set.
Use the source context first.
Find pages where users have no useful next step.
Return the output with these fields:
- page
- dead-end type
- user state affected
- journey stage affected
- missing next step
- recommended path
- fallback path
- anchor direction
- placement
- next workflow route
Flag pages that need content repair before links are added.
Route the output into Behavioral Internal Linking, Drafting and Rewriting, or Support Path Planning.Best for:
- old blogs
- support pages
- docs pages
- landing pages
- orphaned content
Output should include:
- page
- dead-end type
- missing next step
- recommended path
- next route
Use this to:
Reconnect pages that stop user progress.
Dead-end repair can feed link updates or page rewrites.
26. No Next Step Repair
Use this when a page has weak or missing continuation.
Short command:
text
Run No Next Step Repair on this page.Expanded prompt:
text
Run No Next Step Repair on this page.
Use the source context first.
Identify the missing next step after the user gets the main answer.
Return the output with these fields:
- page
- main answer
- missing next step
- recommended next page
- recommended support path
- recommended proof path
- recommended conversion path
- fallback route
- internal link direction
- next workflow route
Do not add a CTA if the user needs proof, comparison, or support first.
Route the output into Behavioral Internal Linking or Drafting and Rewriting.Best for:
- informational pages
- answer pages
- guides
- docs pages
- refresh tasks
Output should include:
- page
- main answer
- missing next step
- recommended path
- fallback route
- next route
Use this to:
Give answer pages a useful continuation path.
A page should not end after the first answer if users need a next route.
27. CTA Friction Review
Use this when CTAs are early, weak, unclear, or risky.
Short command:
text
Run CTA Friction Review on this page.Expanded prompt:
text
Run CTA Friction Review on this page.
Use the source context first.
Review CTAs for timing, trust readiness, effort level, path fit, proof support, placement, wording, and user state.
Return the output with these fields:
- CTA
- placement
- user state
- journey stage
- trust readiness
- effort risk
- friction type
- recommended action
- fallback route
- next workflow route
Flag CTAs that appear before the user has enough proof or clarity.
Route the output into Drafting and Rewriting, Conversion Path Planning, or Testing.Best for:
- product pages
- pricing pages
- service pages
- comparison pages
- conversion paths
Output should include:
- CTA
- placement
- trust readiness
- effort risk
- recommended action
- next route
Use this to:
Make CTAs helpful instead of premature.
A CTA should appear when the user has enough clarity and trust to act.
28. Information Gain and User Gain Score
Use this when a page adds new information but may not help users.
Short command:
text
Run User Gain Score on this page.Expanded prompt:
text
Run User Gain Score on this page.
Use the source context first.
Score the page, passage, internal link, proof block, comparison block, support path, SERP answer, or schema cue by both information gain and user gain.
Return the output with these fields:
- asset
- information gain score
- user gain score
- combined gain score
- user benefit
- semantic benefit
- weak gain area
- recommended action
- owner workflow
- next workflow route
Flag content that is novel but not useful.
Flag content that helps users but needs stronger semantic support.
Route the output into Information Gain, Drafting and Rewriting, or Semantic SEO.Best for:
- information gain reviews
- page refresh
- SERP differentiation
- comparison pages
- drafts
Output should include:
- information gain score
- user gain score
- combined gain score
- weak gain area
- next route
Use this to:
Balance machine-facing usefulness with user-facing usefulness.
Use information gain work when the page needs stronger differentiation and practical user value.
29. Semantic Completeness vs User Usefulness
Use this when a page is complete but hard to use.
Short command:
text
Run Semantic Completeness vs User Usefulness on this page.Expanded prompt:
text
Run Semantic Completeness vs User Usefulness on this page.
Use the source context first.
Compare semantic coverage with user usefulness.
Return the output with these fields:
- page or passage
- semantic completeness score
- user usefulness score
- missing user need
- excess complexity
- friction point
- effort driver
- recommended fix
- next workflow route
Flag pages that are comprehensive but hard to act on.
Route the output into Drafting and Rewriting, Effort Reduction Plan, or UX Content Component Recommendation.Best for:
- long guides
- semantic SEO pages
- documentation
- educational pages
- dense drafts
Output should include:
- semantic completeness score
- user usefulness score
- missing need
- effort driver
- next route
Use this to:
Keep strong coverage from becoming hard to use.
A complete page still needs clear next steps, summaries, proof, and path choices.
30. UX Content Component Recommendation
Use this when a page needs tables, summaries, proof blocks, or decision aids.
Short command:
text
Run UX Content Component Recommendation on this page.Expanded prompt:
text
Run UX Content Component Recommendation on this page.
Use the source context first.
Recommend page components that reduce effort, improve trust, support comparison, clarify decisions, or help the next step.
Return the output with these fields:
- page
- component type
- component purpose
- placement
- user state served
- journey stage served
- friction reduced
- trust supported
- effort reduced
- next workflow route
Use components such as summary boxes, comparison tables, proof blocks, decision aids, checklists, calculators, examples, steps, FAQ blocks, support blocks, and CTA blocks.
Route the output into Content Briefs or Drafting and Rewriting.Best for:
- briefs
- draft reviews
- comparison pages
- docs pages
- support pages
Output should include:
- component type
- component purpose
- placement
- user state served
- next route
Use this to:
Add helpful structure without turning the page into clutter.
Components should reduce effort and support the next step.
31. Behavioral SERP Validation
Use this when SERP formatting must also serve the user path.
Short command:
text
Run Behavioral SERP Validation on this SERP plan.Expanded prompt:
text
Run Behavioral SERP Validation on this SERP plan.
Use the source context first.
Validate SERP-facing blocks against user state, journey stage, friction, trust, effort, passage role, user gain, information gain, and schema support.
Return the output with these fields:
- SERP target
- page block
- user state fit
- journey fit
- trust support
- effort risk
- user gain
- schema support
- risk flags
- next workflow route
Reject SERP targets that increase clicks but weaken the landing page experience.
Route the output into SERP Feature Planning, Drafting and Rewriting, or Behavioral Schema Adaptation.Best for:
- featured snippet blocks
- PAA blocks
- FAQ blocks
- tables
- rich result planning
Output should include:
- SERP target
- page block
- user state fit
- user gain
- risk flags
- next route
Use this to:
Keep snippet, FAQ, table, list, and rich result planning aligned with user value.
A SERP block should help the user after the click, not only attract the click.
32. Behavioral Schema Adaptation
Use this when schema cues need user path validation.
Short command:
text
Run Behavioral Schema Adaptation on this approved draft.Expanded prompt:
text
Run Behavioral Schema Adaptation on this approved draft.
Use the source context first.
Review schema candidates against visible content, user state, journey stage, trust needs, effort reduction, SERP fit, and supported evidence.
Return the output with these fields:
- schema type
- supported content
- unsupported field
- user value
- trust support
- effort support
- risk flag
- schema readiness
- next workflow route
Do not create schema from hidden or unsupported content.
Route the output into Schema Cues after approval or Compliance Audit.Best for:
- approved drafts
- FAQ pages
- how-to pages
- product pages
- software pages
Output should include:
- schema type
- supported content
- unsupported field
- user value
- schema readiness
Use this to:
Keep structured data aligned with visible user value.
Schema cues should follow approved content, not lead it.
33. Behavior Data Review
Use this when analytics, GSC, heatmaps, clicks, or support data are available.
Short command:
text
Run Behavior Data Review on this page set.Expanded prompt:
text
Run Behavior Data Review on this page set.
Use the source context first.
Review available behavior data for user path signals.
Return the output with these fields:
- page
- data source
- behavior signal
- likely interpretation
- affected user state
- affected journey stage
- affected path
- confidence
- privacy note
- next workflow route
Use only privacy-safe, aggregated, or non-sensitive signals.
Route the output into Satisfaction Signal Ingest, Friction Point Extraction, or Behavioral Feedback Loop.Best for:
- post-publish review
- analytics exports
- heatmap notes
- click tracking
- support signals
Output should include:
- data source
- behavior signal
- likely interpretation
- confidence
- next route
Use this to:
Turn analytics and behavior notes into safe workflow evidence.
Behavior data should support decisions without exposing private user data.
34. Satisfaction Signal Ingest
Use this after publishing or testing.
Short command:
text
Run Satisfaction Signal Ingest on this performance data.Expanded prompt:
text
Run Satisfaction Signal Ingest on this performance data.
Use the source context first.
Normalize satisfaction and dissatisfaction signals from search, analytics, support, CRM, feedback, scroll, click, internal search, form, link, CTA, SERP, schema, and experiment data.
Return the output with these fields:
- page or asset
- signal source
- signal type
- satisfaction score
- dissatisfaction score
- confirmation score
- confidence
- root cause candidate
- recommended fix
- recommended test
- next workflow route
Use privacy-safe signal handling.
Route the output into Behavioral Feedback Loop, Testing, or Monitoring.Best for:
- post-publish review
- A/B test review
- page refresh
- support path review
- user path monitoring
Output should include:
- signal source
- signal type
- satisfaction score
- confidence
- next route
Use this to:
Confirm or challenge the assumptions made before publishing.
Satisfaction signals show which paths should be reinforced, revised, tested, or monitored.
35. Behavioral Feedback Loop
Use this when satisfaction signals need action.
Short command:
text
Run Behavioral Feedback Loop on these satisfaction signals.Expanded prompt:
text
Run Behavioral Feedback Loop on these satisfaction signals.
Use the source context first.
Turn satisfaction signals into revise, reinforce, test, monitor, suppress, or rollback decisions.
Return the output with these fields:
- affected asset
- signal direction
- confidence
- validated assumption
- challenged assumption
- recommended action
- owner workflow
- rollback need
- test need
- next workflow route
Do not make permanent changes from weak or noisy signals.
Route the output into Drafting and Rewriting, Behavioral Internal Linking, UX Components, SERP Validation, Schema Adaptation, or Testing.Best for:
- monitoring
- post-publish changes
- experiments
- link path review
- UX component review
Output should include:
- affected asset
- signal direction
- validated assumption
- challenged assumption
- next route
Use this to:
Make post-publish signals actionable.
The feedback loop decides what to keep, revise, test, monitor, suppress, or roll back.
36. Experimentation Variant Planning
Use this when signals are mixed or risk is high.
Short command:
text
Run Experimentation Variant Planning on this behavioral issue.Expanded prompt:
text
Run Experimentation Variant Planning on this behavioral issue.
Use the source context first.
Create controlled variants for content, passages, anchors, CTAs, proof blocks, comparison blocks, support routes, UX components, SERP blocks, schema candidates, or page structure.
Return the output with these fields:
- hypothesis
- control
- variant
- affected page
- target user state
- target journey stage
- primary metric
- guardrail metrics
- rollback criteria
- review need
- next workflow route
Do not launch high-risk tests without review.
Route the output into Behavioral Validation or Monitoring.Best for:
- mixed signals
- CTA tests
- link path tests
- proof placement tests
- UX component tests
Output should include:
- hypothesis
- control
- variant
- metrics
- rollback criteria
- next route
Use this to:
Test uncertainty before permanent changes are made.
Experiment plans should include guardrails and rollback criteria.
37. Behavioral Validation
Use this before publishing, testing, syncing, or rolling back changes.
Short command:
text
Run Behavioral Validation on this release package.Expanded prompt:
text
Run Behavioral Validation on this release package.
Use the source context first.
Validate the behavioral chain before publish, test, schema deploy, link update, or rollback.
Return the output with these fields:
- item tested
- validation result
- user state fit
- journey fit
- friction result
- trust result
- effort result
- link result
- SERP result
- schema result
- owner fix
- retest condition
- next workflow route
Block items with privacy, compliance, schema, SERP, link, CTA, experiment, or satisfaction risks.
Route the output into Compliance Audit or Publish Readiness.Best for:
- release packages
- link updates
- CTA changes
- experiments
- schema cue handoffs
Output should include:
- item tested
- validation result
- risk result
- owner fix
- next route
Use this to:
Check the full behavioral chain before changes ship.
Validation catches weak user path, trust, effort, link, SERP, and schema decisions.
38. Behavioral Compliance Audit
Use this when behavioral recommendations may create risk.
Short command:
text
Run Behavioral Compliance Audit on this behavioral output.Expanded prompt:
text
Run Behavioral Compliance Audit on this behavioral output.
Use the source context first.
Audit behavioral changes for unsupported claims, misleading schema, proof risk, pricing ambiguity, review risk, local mismatch, accessibility risk, privacy risk, CTA risk, experiment risk, and rollback gaps.
Return the output with these fields:
- change
- risk type
- affected page
- evidence status
- compliance decision
- required fix
- human review need
- rollback state
- owner workflow
- next workflow route
Block risky changes until evidence, review, or revision is complete.
Route the output into Publish Readiness or Revision.Best for:
- schema changes
- CTA changes
- pricing paths
- proof claims
- experiments
Output should include:
- change
- risk type
- evidence status
- compliance decision
- next route
Use this to:
Protect the user and the site before publishing or testing.
Behavioral changes should not create unsupported claims, privacy risk, or misleading structured data.
39. Behavioral Publish Readiness
Use this before release.
Short command:
text
Run Behavioral Publish Readiness on this page package.Expanded prompt:
text
Run Behavioral Publish Readiness on this page package.
Use the source context first.
Check if the page, cluster, internal links, CTAs, proof blocks, SERP targets, schema cues, UX components, and monitoring plan are ready to publish.
Return the output with these fields:
- page or package
- readiness status
- blockers
- required fixes
- measurement plan
- rollback plan
- owner workflow
- publish, hold, revise, test, or monitor
- next workflow route
Do not approve publishing if the user path is unclear or unsupported.
Route the output into Publishing or Monitoring.Best for:
- final QA
- page launch
- cluster launch
- CTA updates
- link updates
Output should include:
- readiness status
- blockers
- required fixes
- measurement plan
- next route
Use this to:
Create the final user path gate before release.
Publish readiness should confirm path clarity, proof support, effort reduction, and monitoring.
40. Behavioral Monitoring Plan
Use this to define post-publish measurement.
Short command:
text
Run Behavioral Monitoring Plan for this page.Expanded prompt:
text
Run Behavioral Monitoring Plan for this page.
Use the source context first.
Create a monitoring plan for user path, effort, trust, satisfaction, internal link use, CTA readiness, support success, SERP fit, schema behavior, and experiment outcomes.
Return the output with these fields:
- page
- primary metric
- secondary metrics
- guardrail metrics
- measurement window
- data source
- privacy note
- alert threshold
- owner workflow
- next workflow route
Use only safe measurement fields.
Route the output into Satisfaction Signal Ingest or Behavioral Dashboard Handoff.Best for:
- post-publish tracking
- experiment tracking
- support path review
- conversion path review
- link performance review
Output should include:
- primary metric
- guardrail metrics
- measurement window
- data source
- next route
Use this to:
Make post-publish review part of the workflow.
Monitoring makes behavioral assumptions testable after launch.
41. Behavioral Dashboard Handoff
Use this when behavioral outputs need reporting.
Short command:
text
Run Behavioral Dashboard Handoff on this monitoring package.Expanded prompt:
text
Run Behavioral Dashboard Handoff on this monitoring package.
Use the source context first.
Package behavioral status for review.
Return the output with these fields:
- page or cluster
- satisfaction index
- effort status
- trust status
- path status
- link status
- CTA status
- experiment status
- blockers
- owner actions
- next workflow route
Do not include private user data.
Route the output into Monitoring, Feedback Loop, or Stakeholder Review.Best for:
- reporting
- post-publish review
- team handoff
- experiment summaries
- stakeholder updates
Output should include:
- satisfaction index
- effort status
- trust status
- path status
- owner actions
- next route
Use this to:
Make behavioral health inspectable after publishing.
Dashboard handoff should show the user path status without exposing private data.
42. Behavioral Handoff
Use this to route behavioral outputs downstream.
Short command:
text
Run Behavioral Handoff for this behavioral mapping output.Expanded prompt:
text
Run Behavioral Handoff for this behavioral mapping output.
Use the source context first.
Route each behavioral finding into the correct next workflow.
Return the output with these fields:
- finding
- affected page
- user state
- journey stage
- friction or trust issue
- effort issue
- next path issue
- route to Content Briefs
- route to Drafting and Rewriting
- route to Semantic Internal Linking
- route to Information Gain
- route to SERP Feature Planning
- route to Schema Cues after approval
- route to Testing
- route to Monitoring
- blocked item
- reason
Do not leave behavioral findings without a next action.
Return a clean handoff package.Best for:
- workflow handoff
- team handoff
- large audits
- release planning
- post-publish changes
Output should include:
- finding
- affected page
- user state
- issue type
- route
- blocked items
Use this to:
Move user path decisions into briefs, rewrites, links, SERP, schema, testing, or monitoring.
A behavioral workflow is complete when every useful finding has a next action.
Which Behavioral Mapping Module Should You Run First?
Start with Behavioral Map Scope if the boundary is unclear.
Start with Behavioral Map Goal if the user path job is unclear.
Start with User State Classification if the page exists but the likely user is unclear.
Start with Journey Stage Mapping if the page role exists but the journey step is unclear.
Start with Friction Point Extraction if users appear stuck.
Start with Trust Requirement Mapping if proof is weak.
Start with Effort Score if the page feels hard to use.
Start with Next Best Path if the page has no clear continuation.
Start with Behavioral Internal Linking if the site has pages but weak routes.
Start with Behavioral Publish Readiness if the page is ready for release but needs a final user path gate.
Common Behavioral Mapping Starting Points
I Have an Approved Topical Map
Start with Behavioral Node Annotation.
Prompt:
text
Run Behavioral Node Annotation on this map.
Use the source context first.
Annotate every page or topical node with user path fields.
Return page or node, user state, journey stage, content role, friction profile, trust requirement, effort score, satisfaction signal if available, recommended action, and next workflow route.
Do not change page structure yet.Then run:
text
Run Behavioral Edge Weighting on this map.
Use the source context first.
Score every page-to-page path by semantic fit and user usefulness.
Return source page, target page, edge role, semantic weight, behavioral weight, user state fit, journey fit, friction reduction value, trust support value, effort reduction value, final path priority, anchor direction, and next workflow route.Then run:
text
Run Behavioral Handoff for this behavioral mapping output.
Use the source context first.
Route each useful finding into Content Briefs, Drafting and Rewriting, Semantic Internal Linking, Information Gain, SERP Feature Planning, Schema Cues after approval, Testing, Monitoring, or Blocked.
Return a clean handoff package.Route the result into Content Briefs, Drafting + Rewriting, or semantic internal linking.
I Have a Draft
Start with Passage Role Classification.
Prompt:
text
Run Passage Role Classification on this draft.
Use the source context first.
Classify the role of each passage, block, answer, FAQ, table, CTA, proof block, or support block.
Return current role, intended role, role match score, role conflict, user state fit, journey stage fit, trust support score, effort reduction score, rewrite need, and next workflow route.Then run:
text
Run Passage Order Review on this draft.
Use the source context first.
Review the order of sections, summaries, proof blocks, CTAs, FAQs, tables, and internal links.
Return current section, current position, recommended position, user state reason, journey stage reason, friction reduced, trust need supported, effort reduced, risk note, and next workflow route.Then run:
text
Run Effort Reduction Plan on this effort score.
Use the source context first.
Turn effort drivers into page, passage, link, component, proof, and CTA fixes.
Return recommended reductions, section changes, link changes, component changes, proof changes, test or monitor notes, and next workflow route.Route the result into Drafting + Rewriting.
I Have Weak Internal Links
Start with Behavioral Internal Linking.
Prompt:
text
Run Behavioral Internal Linking on this cluster.
Use the source context first.
Plan internal links based on user state, journey stage, friction, trust, effort, path priority, and semantic relationship.
Return source page, target page, path role, anchor direction, placement, user state fit, journey fit, friction reduced, trust supported, effort reduced, priority, and next workflow route.
Do not add generic links.Then run:
text
Run Anchor Intent Alignment on this link plan.
Use the source context first.
Review anchor text for user state, journey stage, path role, surrounding context, and target page promise.
Return current anchor, recommended anchor direction, anchor intent, surrounding passage, user state fit, journey fit, risk note, and next workflow route.Then run:
text
Run Dead-End Page Repair on this page set.
Use the source context first.
Find pages where users have no useful next step.
Return dead-end type, user state affected, journey stage affected, missing next step, recommended path, fallback path, anchor direction, placement, and next workflow route.Route the result into semantic internal linking or rewrite for internal links.
I Have a Conversion Path Problem
Start with CTA Friction Review.
Prompt:
text
Run CTA Friction Review on this page.
Use the source context first.
Review CTAs for timing, trust readiness, effort level, path fit, proof support, placement, wording, and user state.
Return CTA, placement, user state, journey stage, trust readiness, effort risk, friction type, recommended action, fallback route, and next workflow route.
Flag CTAs that appear before the user has enough proof or clarity.Then run:
text
Run Trust Requirement Mapping on this page.
Use the source context first.
Identify the proof, reassurance, transparency, evidence, methodology, review, author, policy, guarantee, pricing, or local proof needed for the user to continue.
Return trust requirements, trust gaps, proof needed, evidence source, user state, journey stage, content placement, internal link direction, and next workflow route.Then run:
text
Run Conversion Path Planning on this map.
Use the source context first.
Plan routes from education, comparison, proof, docs, and use case pages into conversion pages.
Return source page, conversion target, buyer stage, readiness signal, trust gap, effort risk, CTA placement, fallback path, measurement note, and next workflow route.Route the result into Drafting + Rewriting, internal links, or testing.
I Have Support or Docs Pages
Start with Support Path Planning.
Prompt:
text
Run Support Path Planning on this docs cluster.
Use the source context first.
Plan support routes across setup, troubleshooting, usage, outputs, handoffs, FAQs, templates, and fallback pages.
Return support page, support task, current user state, next support step, fallback path, proof or policy need, link direction, support success signal, and next workflow route.
Flag support pages with no next step.Then run:
text
Run Effort Score on this page.
Use the source context first.
Score the user effort needed to understand, troubleshoot, complete, or continue.
Return effort score, effort drivers, affected user state, affected journey stage, high effort block, recommended reduction, owner workflow, confidence, and next workflow route.Then run:
text
Run UX Content Component Recommendation on this page.
Use the source context first.
Recommend components that reduce effort, improve trust, support comparison, clarify decisions, or help the next step.
Return component type, component purpose, placement, user state served, journey stage served, friction reduced, trust supported, effort reduced, and next workflow route.Route the result into docs briefs or Drafting + Rewriting.
I Have Behavior Data After Publishing
Start with Behavior Data Review.
Prompt:
text
Run Behavior Data Review on this page set.
Use the source context first.
Review available behavior data for user path signals.
Return page, data source, behavior signal, likely interpretation, affected user state, affected journey stage, affected path, confidence, privacy note, and next workflow route.
Use only privacy-safe, aggregated, or non-sensitive signals.Then run:
text
Run Satisfaction Signal Ingest on this performance data.
Use the source context first.
Normalize satisfaction and dissatisfaction signals from search, analytics, support, CRM, feedback, scroll, click, internal search, form, link, CTA, SERP, schema, and experiment data.
Return signal source, signal type, satisfaction score, dissatisfaction score, confirmation score, confidence, root cause candidate, recommended fix, recommended test, and next workflow route.Then run:
text
Run Behavioral Feedback Loop on these satisfaction signals.
Use the source context first.
Turn satisfaction signals into revise, reinforce, test, monitor, suppress, or rollback decisions.
Return validated assumptions, challenged assumptions, recommended action, owner workflow, rollback need, test need, and next workflow route.
Do not make permanent changes from weak or noisy signals.Route the result into monitoring, testing, rewriting, or internal links.
I Need Publish Readiness
Start with Behavioral Validation.
Prompt:
text
Run Behavioral Validation on this release package.
Use the source context first.
Validate the behavioral chain before publish, test, schema deploy, link update, or rollback.
Return validation result, user state fit, journey fit, friction result, trust result, effort result, link result, SERP result, schema result, owner fix, retest condition, and next workflow route.
Block items with privacy, compliance, schema, SERP, link, CTA, experiment, or satisfaction risks.Then run:
text
Run Behavioral Compliance Audit on this behavioral output.
Use the source context first.
Audit behavioral changes for unsupported claims, misleading schema, proof risk, pricing ambiguity, review risk, local mismatch, accessibility risk, privacy risk, CTA risk, experiment risk, and rollback gaps.
Return risk type, affected page, evidence status, compliance decision, required fix, human review need, rollback state, owner workflow, and next workflow route.Then run:
text
Run Behavioral Publish Readiness on this page package.
Use the source context first.
Check if the page, cluster, internal links, CTAs, proof blocks, SERP targets, schema cues, UX components, and monitoring plan are ready to publish.
Return readiness status, blockers, required fixes, measurement plan, rollback plan, owner workflow, publish, hold, revise, test, or monitor decision, and next workflow route.Route the result into publishing or monitoring.
Output Review Checklist for Behavioral Mapping
Before moving downstream, check the behavioral output for:
- source context fit
- user state
- journey stage
- page role
- friction points
- trust requirements
- proof paths
- comparison paths
- support paths
- conversion paths
- effort score
- effort reduction actions
- next best path
- fallback path
- behavioral internal link direction
- anchor intent
- passage role warnings
- CTA friction warnings
- user gain score
- SERP fit from a user path angle
- schema fit from a user path angle
- satisfaction signals
- feedback decisions
- experiment needs
- compliance risks
- publish readiness
- monitoring plan
- downstream workflow routes
Do not move into publishing, schema deployment, link implementation, CTA changes, or experiments if user path, proof, trust, effort, privacy, compliance, or rollback risks are unresolved.
How Behavioral Mapping Connects to Other MIRENA Workflows
Behavioral Mapping and User Path Workflows are the user path layer.
They feed other workflows but do not replace them.
A behavioral page plan can feed Content Briefs when the next job is writer instruction.
A passage role or effort output can feed Drafting + Rewriting when the next job is page repair.
A behavioral link plan can feed semantic internal linking when the next job is route building.
A user gain score can feed information gain work when the next job is useful differentiation.
A behavioral path review can feed Semantic SEO when the next job is meaning, coverage, and topic fit from the user’s angle.
An entity-heavy page can feed Entity SEO when the next job is entity structure, entity clarity, and entity support.
Use MIRENA workflow when you need to decide the next route. Use MIRENA outputs when the behavioral package needs to follow a set handoff format.
Behavioral Mapping Mistakes to Avoid
Mistake 1: Running Behavioral Prompts Without Source Context
Do not change paths, links, CTAs, or proof blocks before source context is loaded.
Source context tells MIRENA which users, offers, topics, and routes belong in the site.
Mistake 2: Treating Behavior Data as a Command
Behavior data is evidence, not an order.
A path can get clicks and still fail the user. A CTA can get attention and still appear too early. Use behavior data with source context, user state, and journey stage.
Mistake 3: Sending Every User Toward Conversion
Not every user is ready to act.
Some users need proof, comparison, support, a simpler answer, or a fallback path first.
Mistake 4: Adding Links Without Path Logic
A link should help the user continue.
Do not add generic links only because pages are topically related. Use Behavioral Internal Linking and Anchor Intent Alignment.
Mistake 5: Reducing Effort by Removing Useful Depth
Effort reduction does not mean making every page shorter.
It means adding summaries, clearer order, better components, better links, stronger proof, and clearer next steps.
Mistake 6: Treating SERP Wins as User Wins
A snippet, table, or FAQ block can attract clicks but still create a poor landing page experience.
Use Behavioral SERP Validation before pushing SERP formats.
Mistake 7: Creating Schema Without Visible User Value
Schema should reflect approved visible content.
Use Behavioral Schema Adaptation before schema cues move forward.
Mistake 8: Skipping Monitoring
Behavioral decisions should be checked after publishing.
Use Monitoring, Satisfaction Signal Ingest, and the Behavioral Feedback Loop to reinforce, revise, test, suppress, or roll back decisions.
FAQs About Behavioral Mapping and User Path Prompts in MIRENA
What is Behavioral Mapping in MIRENA?
Behavioral Mapping is the workflow that adds user state, journey stage, friction, trust, effort, next steps, fallback paths, satisfaction signals, testing, and monitoring to MIRENA outputs.
It helps a structured page or site become easier for users to follow.
What should I run first?
Start with Behavioral Map Scope if the project boundary is unclear.
Start with Behavioral Map Goal if the user path job is unclear.
Start with User State Classification if you need to understand who the page serves.
Start with Friction Point Extraction if users appear stuck.
Start with Next Best Path if the page has no clear continuation.
Is Behavioral Mapping the same as Topical Mapping?
No.
Topical Mapping builds site structure.
Behavioral Mapping checks user state, journey stage, friction, trust, effort, links, CTAs, proof, support, and next paths inside that structure.
Is Behavioral Mapping the same as Entity SEO?
No.
Entity SEO clarifies meaning and relationships.
Behavioral Mapping clarifies user movement, user effort, proof needs, support needs, and next steps.
Can behavioral prompts improve internal links?
Yes.
Behavioral Internal Linking uses user state, journey stage, friction, trust, effort, path priority, and semantic relationship to recommend links.
Use semantic internal linking when the link plan also needs cluster and architecture support.
Can behavioral prompts improve drafts?
Yes.
Use Passage Role Classification, Passage Order Review, Friction Point Extraction, Effort Score, CTA Friction Review, and UX Content Component Recommendation before a rewrite.
Can behavioral prompts improve content briefs?
Yes.
A behavioral output can tell the brief which user state to serve, which journey stage the page targets, what proof is needed, what the next path should be, and which components should appear.
Can behavioral prompts use analytics data?
Yes.
Use Behavior Data Review, Satisfaction Signal Ingest, Behavioral Feedback Loop, and Monitoring Plan.
Use privacy-safe, aggregated, and non-sensitive data only.
Can behavioral prompts help with schema?
Yes, but only after the draft is approved.
Use Behavioral Schema Adaptation to confirm schema cues are supported by visible content and useful to the user.
Can behavioral prompts help with SERP features?
Yes.
Behavioral SERP Validation checks if snippets, FAQs, tables, and other SERP blocks help the user after the click.
What should I do after Behavioral Mapping?
Move the output into the correct next workflow.
Use Content Briefs when the next job is writer instruction.
Use Drafting + Rewriting when the next job is page repair.
Use semantic internal linking when the next job is route building.
Use information gain work when the page needs useful differentiation.
Use SERP feature planning when page blocks need search result formatting.
Use schema cues only after a page draft is approved.
Use testing and monitoring when the evidence is mixed or the change is risky.