Using Hopper to Draft Decisions from Natural Language

This article provides a comprehensive guide on leveraging Hopper, Hopsule’s advisory AI assistant, to transform natural language descriptions into structured, enforceable decisions. By using Hopper to bridge the gap between raw intent and formal governance, engineering teams can ensure that organizational judgment is preserved with full context and traceability.

Prerequisites

Before using Hopper to draft decisions, ensure you have met the following requirements:

• An active Hopsule account with "Editor" or "Admin" permissions for the relevant project.

• Access to the Hopsule Dashboard or the Hopsule CLI.

• (Optional) Existing Memories within your project to provide Hopper with historical context and reasoning.

• (Optional) An active installation of Hopsule for VS Code if you intend to draft decisions directly from your development environment.

The Philosophy of Drafting with Hopper

In Hopsule, a decision is not merely a record; it is a commitment that shapes the future of your engineering organization. Hopper acts as an advisory layer that helps you articulate these commitments. Hopper does not make decisions for you—authority remains strictly with human team members—but it excels at identifying conflicts, suggesting rationales based on existing Memories, and ensuring that your Context Packs remain consistent over time.

Step 1: Accessing the Drafting Interface

There are three primary ways to initiate a decision draft using natural language. Choose the interface that best fits your current workflow.

Via the Hopsule Dashboard

1. Log in to the Hopsule Dashboard and select your organization and project from the sidebar.

2. Navigate to the Decisions tab in the primary navigation menu.

3. Click the Create Decision button located in the top-right corner.

4. Select the Draft with Hopper option from the dropdown menu. This will open the Hopper drafting modal.

Via the Hopsule CLI

1. Open your terminal and ensure you are authenticated by running hopsule auth status.

2. Execute the command hopsule decision draft --interactive.

3. When prompted, provide your natural language description. Hopper will process this input and present a structured draft within the TUI (Terminal User Interface).

Via Hopsule for VS Code

1. Highlight a block of code or a comment in your editor that represents a pattern or rule you wish to formalize.

2. Right-click and select Hopsule: Draft Decision from Selection.

3. Hopper will open a side panel in VS Code with a proposed decision draft based on the selected code context and your project's existing Memories.

Step 2: Providing the Natural Language Seed

Hopper requires a "seed"—a plain-language description of what you want to achieve. For the best results, your seed should include the "what," the "why," and any specific constraints. Unlike traditional tools, you do not need to worry about formatting; Hopper will handle the structural enforcement.

Example Seed: "We need to stop using external state management libraries in our frontend components. From now on, use native context or local state. This is because our bundle size is getting too large and we've had issues with library-specific memory leaks in the past."

When you input this into the Hopsule Dashboard, Hopper begins a multi-step analysis:

• Context Retrieval: Hopper scans your Knowledge Graph for related Memories regarding bundle size or state management.

• Conflict Detection: Hopper checks if this new draft contradicts any existing Accepted decisions.

• Categorization: Hopper suggests relevant tags and Context Packs for the decision.

Step 3: Reviewing the Structured Draft

Once Hopper processes your seed, it will present a structured draft. It is critical to review each field to ensure it accurately reflects your team's judgment.

The Title

Hopper will generate a concise, authoritative title. For the example above, it might suggest: "Standardization of Frontend State Management to Native Context."

The Description

This is a clear statement of the decision. Hopper ensures the language is prescriptive rather than descriptive, moving from "We should" to "We will" or "All components must."

The Rationale (Linked Memories)

This is the most vital part of the Hopsule ecosystem. Hopper will attempt to link the draft to existing Memories. If Hopper finds a memory entry from six months ago regarding a memory leak in a specific library, it will automatically cite that memory as the justification for this decision. This ensures full traceability of organizational judgment.

Constraints and Enforcement Rules

Hopper will extract specific constraints. For instance, it may define a constraint that triggers a warning in Hopsule for VS Code whenever a developer attempts to import a forbidden state management library. You can refine these constraints in the Enforcement tab of the drafting modal.

Step 4: Refining and Iterating

If the initial draft isn't perfect, you can iterate with Hopper. In the Hopsule Dashboard, use the Refine with Hopper chat interface below the draft.

• Request Alternatives: "Hopper, what if we allow exceptions for large-scale data grids?"

• Deepen Reasoning: "Hopper, find more memories related to our bundle size performance targets to bolster the rationale."

• Adjust Scope: "Hopper, limit this decision to the 'Mobile App' Context Pack only."

Step 5: Transitioning to "Pending"

Once you are satisfied with the draft, click the Submit for Review button. The decision's lifecycle will move from Draft to Pending. At this stage, other team members will be notified via the Activity Feed and can provide feedback or move the decision to Accepted. Remember: Hopper cannot accept a decision. Only a human with appropriate authority can finalize the enforcement of a decision.

Advanced Usage: Hopsule MCP for AI Agents

If your team uses AI agents (such as those found in Cursor or Claude), the Hopsule MCP (Model Context Protocol) allows these agents to interact with Hopper's drafting capabilities. When an AI agent is writing code, you can instruct it: "Check Hopsule to see if this pattern follows our decisions, and if not, draft a new decision using Hopper." The MCP server will facilitate this connection, allowing the AI agent to read existing context and submit a draft to your Hopsule Dashboard for human review.

Tips and Best Practices

• Reference Specific Memories: When providing a seed to Hopper, mention specific events or past lessons. Hopper is designed to find and link these to ensure your decisions are grounded in history.

• Use Context Packs (Capsules): If a decision only applies to a specific part of your infrastructure, tell Hopper which Context Pack it belongs to. This prevents "context noise" for teams working on unrelated projects.

• Draft Often, Accept Carefully: Encourage your team to draft decisions whenever a recurring pattern emerges. Because Memories are append-only and never lost, even a draft that is eventually deprecated provides valuable context for future engineers.

• Leverage the Knowledge Graph: Before finalizing a draft, view it in the Brain (Knowledge Graph) interface. This allows you to see how the new decision connects to other parts of your organizational memory.

• Review Conflict Warnings: Never ignore a conflict warning from Hopper. If a new draft contradicts an Accepted decision, you must either refine the draft or deprecate the old decision first.

Troubleshooting

Related Articles

• Understanding the Decision Lifecycle: From Draft to Deprecated

• Managing Context Packs and Capsules for Multi-Project Governance

• Configuring Inline Enforcement in Hopsule for VS Code

• Preserving Organizational Memory: Best Practices for Append-Only Entries