IN

indicator-buffer

Assists in implementing BufferList incremental indicators for chain or quote processing.

Install

mkdir -p .claude/skills/indicator-buffer && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/4121" && unzip -o skill.zip -d .claude/skills/indicator-buffer && rm skill.zip

Installs to .claude/skills/indicator-buffer

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Implement BufferList incremental indicators with efficient state management. Use for IIncrementFromChain or IIncrementFromBar implementations. Covers interface selection, constructor patterns, and BufferListTestBase testing requirements.
237 chars✓ has a “when” trigger
Advanced

Key capabilities

  • Implement incremental indicators
  • Manage state for IIncrementFromChain or IIncrementFromBar
  • Verify series parity in tests
  • Register indicators in the catalog

How it works

The skill provides a framework for developing incremental indicators by inheriting from BufferList, implementing specific interfaces, and using rolling buffers for efficient state management.

Inputs & outputs

You give it
Indicator parameters and input data
You get back
Incremental indicator implementation

When to use indicator-buffer

  • Implement financial indicators
  • Use BufferList for state management
  • Write tests for indicator implementations

About this skill

BufferList indicator development

Interface selection

InterfaceAdditional InputsUse Case
IIncrementFromChainIReusable, (DateTime, double)Chainable single-value indicators
IIncrementFromBar(none — only IBar from base)Requires OHLCV properties

See references/interface-selection.md for decision tree.

Constructor pattern

The chaining constructor parameter type depends on the interface implemented:

// IIncrementFromChain — chaining ctor takes IReadOnlyList<IReusable>
public class EmaList : BufferList<EmaResult>, IIncrementFromChain, IEma
{
    public EmaList(int lookbackPeriods)
    {
        Ema.Validate(lookbackPeriods);
        LookbackPeriods = lookbackPeriods;
        _buffer = new Queue<double>(lookbackPeriods);
    }

    public EmaList(int lookbackPeriods, IReadOnlyList<IReusable> values)
        : this(lookbackPeriods) => Add(values);
}
// IIncrementFromBar — chaining ctor takes IReadOnlyList<IBar>
public class AdxList : BufferList<AdxResult>, IIncrementFromBar, IAdx
{
    public AdxList(int lookbackPeriods)
    {
        Adx.Validate(lookbackPeriods);
        LookbackPeriods = lookbackPeriods;
    }

    public AdxList(int lookbackPeriods, IReadOnlyList<IBar> bars)
        : this(lookbackPeriods) => Add(bars);
}

Buffer management

  • _buffer.Update(capacity, value) — standard rolling buffer
  • _buffer.UpdateWithDequeue(capacity, value) — returns dequeued value for sum adjustment

State management

Use Clear() to reset all internal state:

public override void Clear()
{
    base.Clear();
    _buffer.Clear();
    _bufferSum = 0;
}

Testing constraints

  • Inherit BufferListTestBase
  • IIncrementFromChain → implement ITestChainBufferList
  • IIncrementFromBar → implement ITestBarBufferList
  • Series parity: bufferResults.IsExactly(seriesResults)

Required implementation

  • Source code: src/**/{IndicatorName}List.cs file exists
    • Inherits BufferList<TResult> and implements correct increment interface
    • Two constructors: primary + chaining via : this(...) => Add(...);
    • Uses BufferListUtilities.Update() or UpdateWithDequeue()
    • Clear() resets results and all internal buffers
  • Unit testing: tests/Library/Indicators/**/{IndicatorName}BufferListTests.cs exists
    • Inherits BufferListTestBase and implements correct test interface
    • All required abstract + interface methods implemented
    • Verifies equivalence with Series results
  • Catalog registration: Registered in Catalog.Listings.cs
  • Performance benchmark: Add to tools/performance/Perf.Buffer.cs
  • Public documentation: Update docs/indicators/{IndicatorName}.md
  • Regression tests: Add to tests/Library/Indicators/**/{IndicatorName}RegressionTests.cs
  • Migration guide: Update docs/migration/v3.md for notable and breaking changes from v2

When not to use it

  • When implementing non-incremental indicators
  • When the indicator does not require state management

Prerequisites

BufferList base classBufferListTestBase for testing

Limitations

  • Requires adherence to specific constructor patterns
  • Testing requires implementation of specific test interfaces

How it compares

It enforces a standardized development and testing pattern for incremental indicators, ensuring consistency and performance compared to ad-hoc implementations.

Compared to similar skills

indicator-buffer side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
indicator-buffer (this skill)11moNo flagsAdvanced
zod-4127moNo flagsIntermediate
develop-ai-functions-example56moReviewIntermediate
agent-implementer-sparc-coder16moReviewIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

Search skills

Search the agent skills registry