Credit Optimization Best Practices

Get the most value from your Rock Smith credits by understanding costs and applying strategic optimization techniques.

Understanding Credit Economics

Credit Cost Reference

Every operation in Rock Smith consumes credits:

Operation	Credit Cost	Notes
Discovery Session	1 per agent step	Typically 50-100 steps per session
Flow Execution	1 per agent step	Typically 10-20 steps per flow
Flow Generation	1 per flow	From visual contexts
Flow Refinement	1 per refinement	Minor adjustments
Edge Case Fuzzing	1 per variant	Generation only
Persona Generation	1 per persona	AI-generated personas

Plan Comparison

Plan	Monthly Cost	Included Credits	Effective Rate	Overage Rate
Pay-As-You-Go	—	—	$0.10/credit	—
Growth	$39	550	~$0.071/credit	$0.09
Professional	$149	2,000	~$0.075/credit	$0.06

Annual plans save 2 months (Growth: $390/year, Professional: $1,490/year).

Choosing the Right Plan

Monthly Usage	Recommended Plan	Why
< 200 credits	Pay-As-You-Go	Lower total cost
200-600 credits	Growth	Best per-credit value
600+ credits	Professional	Lowest overage rate

tip

If you're unsure, start with Pay-As-You-Go to measure actual usage, then upgrade to a subscription once patterns are clear.

Discovery Session Optimization

Discovery is often the largest credit consumer. Optimize carefully.

Scope Management

Scope Type	Agent Steps	Best For
Targeted	20-50	Single feature area
Moderate	50-100	Product section
Broad	100-200+	Full application

Cost-saving strategies:

1. Use URL exclusions aggressively

   • Exclude admin panels, logout pages, external links
   • Exclude areas already explored in previous sessions
   • Add patterns at project level for persistent exclusions

2. Start small, expand as needed

   • Begin with targeted discovery for immediate needs
   • Run additional sessions only when coverage gaps appear

3. Monitor in real-time

   • Stop early if step-to-context ratio is poor
   • End sessions when target areas are covered

Reusing Visual Contexts

Visual contexts persist across sessions. Leverage existing contexts:

Approach	Credit Cost
New discovery	50-100+ credits
Generate flow from existing context	1 credit

When to reuse contexts:

• Application hasn't changed significantly
• Existing contexts cover the needed areas
• Quick turnaround needed

When to re-discover:

• Major UI redesign
• New features added
• Contexts are stale (months old)

Flow Execution Optimization

Every flow execution consumes 1 credit per agent step. Reduce step count and avoid wasted runs.

Reducing Agent Steps

Technique	Savings	How
Focused flows	20-30%	Keep flows to 10-15 steps
Clear targeting	10-20%	Better descriptions = faster element location
Efficient waits	10-15%	Use wait_for_element instead of long fixed waits
Combined actions	5-10%	Single step for multi-field forms when appropriate

Efficient Element Targeting

Poor targeting causes retries, which consume extra steps:

Slow (multiple attempts):

Label: "Submit button"

Fast (first attempt):

Label: "Submit button"
Position: "bottom of the form"
Text: "Sign In"
Type: "button"

Investing time in precise targeting descriptions pays off over many executions.

Smart Retry Strategies

Before re-running a failed flow:

1. Review the failure reason in results
2. Fix the underlying issue (targeting, timing, assertion)
3. Verify fix with a single run
4. Then proceed with batch testing

Avoid:

• Re-running failed flows repeatedly hoping for success
• Running flows without reviewing previous failures
• Ignoring intermittent failures (fix root cause)

Flow Generation & Refinement

Generation Strategy

Approach	Cost	Best For
Generate from contexts	1 credit/flow	Quick baseline creation
Manual creation	0 credits	Precise control

Optimize generation:

• Generate flows in batches from well-populated projects
• Review generated flows before execution
• Use discovery contexts efficiently (1 discovery → many flows)

Refinement vs. Regeneration

Action	Cost	When to Use
Refine	1 credit	Minor targeting improvements, assertion tweaks
Regenerate	1 credit	Major restructuring needed
Manual edit	0 credits	Small changes you can make yourself

Refinement is cost-effective for:

• Improving element descriptions
• Adding or adjusting assertions
• Fixing timing issues
• Clarifying step names

tip

Use refinement (1 credit) for iterative improvements. Only regenerate when the flow structure needs fundamental changes.

Edge Case Testing Optimization

Fuzzing can quickly consume credits. Be strategic.

Selective Variant Generation

Focus fuzzing on:

• Authentication flows (login, registration, password reset)
• Payment and checkout
• Data entry forms
• User input handling

Skip fuzzing for:

• Navigation-only flows
• Read-only pages
• Simple click-through flows

Execution Strategy

Fuzzing cost = generation + execution

Example - Thoughtful approach:
- Generate 2 variants: 2 credits
- Run baseline + 1 selected variant: 30 credits
- Total: 32 credits

Example - Unoptimized approach:
- Generate 3 variants: 3 credits
- Run all 4 flows: 60 credits
- Total: 63 credits

Optimization tactics:

• Review generated variants before running
• Run high-risk variants first
• Skip redundant variants (similar scenarios)
• Execute security variants only in staging

Tree Depth Management

Depth	Typical Value	Credit Impact
1-2	High	Moderate
3-4	Medium	Increasing
5-6	Low	High

Stay at depth 2-3 for most use cases. Deep trees have diminishing returns.

Persona Optimization

Efficient Persona Creation

Method	Cost	Best For
AI generation	1 credit/persona	Quick diverse personas
Manual creation	0 credits	Specific requirements

Cost-saving approach:

• Start with 2-3 core personas
• Create manually when you know exact requirements
• Generate only when you need AI creativity

Persona Reuse

Personas persist in your library. Reuse across:

• Multiple flow executions
• Different projects (where applicable)
• Ongoing test cycles

Don't create new personas for:

• Each flow execution
• Minor variations (adjust existing instead)
• One-time tests

Usage Monitoring & Alerts

Tracking Usage

Monitor credit consumption regularly:

1. Check balance: View in app's top-right corner
2. Review breakdown: Click for detailed usage by operation type
3. Identify patterns: Which operations consume most credits?

Setting Alerts

Configure alerts to avoid surprise overages:

Alert Level	When to Alert	Action
75%	Included credits	Review upcoming testing needs
90%	Included credits	Prioritize critical tests only
100%	Included credits	Overages begin; consider upgrade

Budget Planning

Estimating Monthly Usage

Calculate expected credits:

Monthly Credits =
  (Discovery steps/session × sessions) +
  (Flow steps × executions) +
  (Flows generated) +
  (Refinements) +
  (Fuzzing variants generated) +
  (Fuzzing variants executed × steps) +
  (Personas generated)

Example Budgets

Small Team (Growth Plan - 550 credits)

Activity	Calculation	Credits
2 discovery sessions	50 steps × 2	100
10 flow generations	10 × 1	10
30 flow executions	15 steps × 30	450
Total		560

Result: Slightly over, ~$1 overage

Active QA Team (Professional Plan - 2,000 credits)

Activity	Calculation	Credits
4 discovery sessions	60 steps × 4	240
20 flow generations	20 × 1	20
75 flow executions	18 steps × 75	1,350
10 fuzzing variants	10 × 1	10
10 variant executions	18 steps × 10	180
5 refinements	5 × 1	5
Total		1,805

Result: Within plan, 195 credits remaining

Credit-Saving Checklist

Use this checklist to maximize credit efficiency:

Discovery Sessions

• Define URL exclusion patterns
• Select appropriate scope (targeted vs. broad)
• Monitor session metrics in real-time
• Stop early when coverage goals are met
• Reuse existing visual contexts when possible

Flow Execution

• Fix issues before re-running failed flows
• Use precise element targeting descriptions
• Keep flows focused (10-15 steps)
• Use wait_for_element over fixed durations
• Select browser profiles for authenticated flows

Flow Generation

• Generate from existing visual contexts
• Review generated flows before execution
• Use refinement (1 credit) for minor changes
• Make manual edits when possible (0 credits)

Edge Case Testing

• Focus fuzzing on critical flows only
• Review variants before executing all
• Start with 1-2 variants, expand as needed
• Stay at tree depth 2-3 for most cases
• Run security variants in staging only

Personas

• Start with 2-3 core personas
• Create manually when requirements are clear
• Reuse personas across executions
• Don't create new personas for each test

Common Credit Waste Patterns

Pattern	Impact	Solution
Broad discovery without exclusions	100+ wasted credits	Add URL exclusions
Re-running failed flows	15+ credits per run	Fix issues first
Running all fuzzing variants	50+ credits	Review and select
Regenerating instead of refining	1+ credits	Use refinement
New personas per execution	1+ credits	Reuse existing
Overly long flows	5-10 extra steps	Split or simplify

Next Steps

• Managing Credits User Guide - Full pricing and billing reference
• Flow Design Best Practices - Design efficient flows
• Discovery Session Best Practices - Optimize discoveries
• Edge Case Testing Best Practices - Strategic fuzzing