Hyperdimensional Vector Space Golf Scorekeeping Framework
This framework provides a structured approach to organizing feature-complete development using golf metaphors. Instead of temporal milestones (weeks, sprints), development is segmented into 18 "holes," each representing a distinct feature or capability. This methodology emphasizes semantic progression from broad, exploratory prompts to narrowly-scoped, high-precision implementation directives.
🎯 Primary Use Case
When an LLM is asked to create an implementation plan, it should structure the plan using this framework: breaking the work into 18 holes, organizing each hole into 3-5 shots that progress from drives (broad scope) to puts (narrow, precise scope), and ensuring that after 9 holes (at the turn), a releasable product exists.
Core Concepts
18 Holes
The complete feature set is divided into 18 distinct "holes," each representing a major feature, capability, or system component. Holes are not time-based but feature-based, allowing for flexible pacing while maintaining clear segmentation.
Key Principle
Each hole should be a complete, testable feature that can be independently developed and validated.
The Turn (Hole 9)
After completing 9 holes (the "front 9"), the project should have a releasable product with the bulk of core scope implemented and functionally tested. This milestone ensures early value delivery and provides a natural checkpoint for reflection and course correction.
Critical Milestone
The turn represents a shippable product, not just a demo or prototype. Core functionality must be complete and tested.
Shots (3-5 per Hole)
Each hole is broken down into 3-5 "shots," which are high-quality, high-specificity implementation prompt directives. Shots represent the actual work items that move development forward, progressing from broad exploration to precise implementation.
Structure
Each shot should be a complete, actionable prompt that an implementing LLM can execute with clear success criteria.
Shot Continuum
Shots exist on a continuum from drives (large-scope, low-semantically-clamped prompts) to puts (narrowly-scoped, context-specific, high-semantically-clamped prompts). This progression ensures that implementation moves from exploration to precision.
Semantic Clamping
As shots progress from drives to puts, they become more semantically constrained, providing tighter guardrails and clearer success criteria.
Shot Types: From Drives to Puts
Drives
Large ScopeCharacteristics: Large-scope, low-semantically-clamped prompts that allow for exploration and discovery. These shots set the direction and establish the foundational architecture.
- •Broad exploration of solution space
- •Minimal semantic constraints
- •Architectural decisions and design choices
- •Foundation and infrastructure setup
Example Prompt Style:
"Design the overall architecture for user authentication, considering security best practices, scalability, and integration with existing systems. Explore different approaches and recommend a solution."
Approach Shots
Medium ScopeCharacteristics: Medium-scope prompts that narrow the solution space while still allowing for some implementation flexibility. These shots refine the approach established by drives.
- •Refinement of architectural decisions
- •Moderate semantic constraints
- •Component design and interface definitions
- •Integration planning
Example Prompt Style:
"Implement the authentication service layer using the chosen architecture, including user registration, login, and session management. Follow the security patterns established in the design phase."
Chips
Narrow ScopeCharacteristics: Narrowly-scoped prompts that focus on specific implementation details. These shots have clear boundaries and success criteria.
- •Specific feature implementation
- •High semantic constraints
- •Clear success criteria
- •Integration with existing components
Example Prompt Style:
"Add password reset functionality to the authentication service, including email verification, secure token generation, and expiration handling. Use the existing email service interface and follow the established error handling patterns."
Puts
Maximum PrecisionCharacteristics: Narrowly-scoped, context-specific, high-semantically-clamped prompts that steer the implementing LLM to finish the feature implementation with high compliance to requirements and attestable quality.
- •Maximum semantic clamping
- •Context-specific implementation
- •Precise success criteria and validation
- •Quality assurance and testing requirements
Example Prompt Style:
"Fix the password reset token validation bug in AuthService.resetPassword() at line 142. The token should expire after 1 hour, validate the format (UUID-v4), and return AUTH_TOKEN_EXPIRED error code when expired. Add unit tests covering expiration edge cases and update the error handling to match the existing pattern in AuthService.login()."
Guide for LLMs: How to Use This Framework
When to Apply This Framework
Use this framework when asked to create an implementation plan, development roadmap, or feature breakdown. The framework is particularly useful for:
- •Breaking down large features into manageable work items
- •Creating structured implementation prompts
- •Organizing development work without temporal constraints
- •Ensuring early value delivery (releasable product at hole 9)
Step-by-Step Process
- 1
Identify the Complete Feature Set
Break down the project into 18 distinct features, capabilities, or system components. Each hole should represent a complete, testable feature.
- 2
Organize Holes for Early Value
Ensure that holes 1-9 (the front 9) contain the core functionality needed for a releasable product. The turn should represent a meaningful milestone with the bulk of core scope implemented and tested.
- 3
Break Each Hole into 3-5 Shots
For each hole, create 3-5 shots that progress from drives (broad, exploratory) to puts (narrow, precise). Each shot should be a complete, actionable implementation prompt directive.
- 4
Apply Semantic Clamping Progression
Structure shots so that early shots (drives) have low semantic clamping (allow exploration), while later shots (puts) have high semantic clamping (precise requirements, clear success criteria, context-specific).
- 5
Write High-Quality Shot Prompts
Each shot should be a high-quality, high-specificity implementation prompt that an implementing LLM can execute. Include context, requirements, success criteria, and quality attestation requirements.
Key Principles for Shot Prompts
- →Drives: Focus on exploration, architecture, and direction-setting. Allow for multiple valid approaches.
- →Approach Shots: Narrow the solution space while maintaining some flexibility. Refine architectural decisions.
- →Chips: Specify implementation details with clear boundaries. Include integration requirements.
- →Puts: Provide maximum precision with context-specific requirements, exact success criteria, and quality validation steps.
Example Structure
Example: Hole 1 - User Authentication System
"Design the overall architecture for user authentication, considering security best practices, scalability requirements, and integration with existing user management systems. Explore OAuth2, JWT, and session-based approaches, and recommend a solution with rationale."
"Implement the authentication service layer using the chosen architecture, including user registration, login, password hashing, and session management. Follow the security patterns established in the design phase and integrate with the existing user database schema."
"Add password reset functionality to the authentication service, including email verification, secure token generation (UUID-v4), and expiration handling (1-hour TTL). Use the existing email service interface and follow the established error handling patterns."
"Fix the password reset token validation bug in AuthService.resetPassword() at line 142. The token must expire after exactly 1 hour (3600 seconds), validate UUID-v4 format using the regex pattern from TokenValidator, return AUTH_TOKEN_EXPIRED error code (matching AuthError enum), and add unit tests covering expiration edge cases (3599s, 3600s, 3601s) following the test pattern in AuthServiceTest.login()."
Understanding Semantic Clamping
Semantic clamping refers to the degree to which a prompt constrains the solution space and specifies requirements. It's a continuum from low (broad, exploratory) to high (narrow, precise).
Low Semantic Clamping (Drives)
- •Allows multiple valid approaches
- •Exploratory and discovery-oriented
- •Minimal constraints on implementation
- •Focus on "what" and "why"
High Semantic Clamping (Puts)
- •Specifies exact approach and implementation
- •Context-specific with precise requirements
- •Clear success criteria and validation
- •Focus on "how" with exact specifications
Progression Principle: As you move through shots in a hole, each subsequent shot should have higher semantic clamping than the previous one. This ensures that implementation moves from broad exploration to precise execution, maintaining momentum while increasing precision.
Quality and Attestation
Each shot prompt should include requirements for quality attestation. As shots progress from drives to puts, the quality requirements should become more specific and measurable.
Quality Requirements by Shot Type
- Drives:Documentation of decisions, rationale, and trade-offs
- Approach Shots:Code review checklist, integration tests, architectural compliance
- Chips:Unit tests, integration tests, error handling validation
- Puts:Comprehensive test coverage, edge case validation, performance benchmarks, code quality metrics, and explicit success criteria verification
Additional Resources
Golf Philosophy Slides
Explore the 10 shot archetypes with detailed visualizations, prompt examples, and heuristic definitions.
Scorecard Dashboard
View live project data, insights, trajectories, and manifold visualizations using the scorecard framework.
Prototypes
Explore working implementations and experimental features built using this framework.
Diagrams
Navigate ontology-first diagrams, including semantic manifolds and archetype terrains.