The Rimewood Method: Player Experience Meets Technical Precision
A development approach built on understanding what players feel, iterating based on real feedback, and executing with technical reliability.
Back to HomeThe Foundation: Why Player Experience Comes First
Games Are Felt Before They're Understood
Players form impressions about your game in seconds, based primarily on how it feels to play rather than any intellectual understanding of its systems. A platformer with slightly delayed jump response will frustrate players even if the delay is technically minimal. A leaderboard that updates slowly will feel unreliable regardless of its actual accuracy. Our development starts with these felt experiences because they determine whether players engage with your game or abandon it.
Iteration Reveals What Works
The gap between how a feature seems like it should work and how it actually feels to use can only be discovered through iteration. Building complete systems before testing them leads to costly late-stage changes. Our approach involves regular playtesting throughout development, catching issues when they're still easy to address and validating successful elements before building upon them.
Technical Quality Enables Creative Freedom
Solid technical foundation doesn't constrain creativity—it enables it. When core systems work reliably, you can experiment with features and content without worrying whether the underlying architecture will support your ideas. Clean code structures and scalable systems mean additions and adjustments happen smoothly rather than requiring extensive rewrites.
Communication Prevents Misalignment
Most development problems stem from misaligned expectations rather than technical limitations. Regular check-ins, clear documentation, and honest discussions about tradeoffs keep everyone working toward the same vision. When concerns arise, addressing them through conversation prevents small issues from becoming major problems.
The Rimewood Method In Practice
Our development process adapts to each project's specific needs, but these core principles guide every engagement.
Discovery & Requirements
Understanding what you're building and why comes before any technical work. We discuss your vision, identify core gameplay or feature requirements, and establish clear priorities. This phase includes questions about target audience, platform considerations, and technical constraints. Better to surface potential challenges now than after significant development effort.
Prototype & Core Mechanics
Early builds focus on fundamental feel rather than visual polish. For platformers, this means getting movement right. For competitive features, this means establishing reliable backend systems. These prototypes answer essential questions about whether the core concept works as intended, allowing for direction changes before significant resources are committed.
Iterative Development
Development proceeds in stages with regular builds for feedback. Each iteration adds features or refines existing ones based on your input and playtesting results. This approach makes progress visible throughout the project and allows adjustments to happen naturally as understanding improves. Weekly check-ins keep everyone aligned on current status and upcoming work.
Playtesting & Refinement
Testing with players who match your target audience reveals issues internal testing misses. We observe how people actually interact with your game, noting where they struggle, what they enjoy, and whether features communicate their purpose clearly. This feedback guides refinement priorities, ensuring development effort focuses on improvements that matter most to player experience.
Polish & Optimization
Final development phase concentrates on performance optimization, bug fixing, and visual polish. Changes become smaller and more focused on refinement rather than adding features. Testing becomes more thorough, covering edge cases and different player approaches. This phase ensures the project meets quality standards and performs reliably across intended platforms.
Delivery & Support
Project delivery includes complete documentation, source code, and any assets created during development. Post-launch support period addresses questions or issues that arise in real-world usage. We remain available to help with technical questions or minor adjustments during this period, ensuring smooth transition from development to live operation.
This process adapts to project scope—smaller features may combine phases, while larger projects might repeat certain phases for different systems. The core principle remains constant: regular feedback and iterative refinement lead to better results than trying to plan everything perfectly upfront.
Built On Established Principles
Industry-Standard Development Practices
Our technical approach follows established game development patterns that have proven effective across the industry. Version control, modular code architecture, and systematic testing aren't innovations—they're standard practices that we implement thoroughly because they work reliably.
We use Unity for most projects due to its extensive documentation, strong community support, and proven performance across multiple platforms. This choice means your project benefits from years of engine optimization and a vast ecosystem of solutions to common challenges.
User Experience Research Principles
Player experience design draws from decades of research in human-computer interaction and cognitive psychology. Concepts like feedback loops, affordances, and cognitive load aren't game-specific—they apply to any interactive system. We apply these principles to game mechanics because they predict player behavior reliably.
For example, the coyote time and input buffering techniques we use in platformer development aren't arbitrary choices. They compensate for documented limitations in human reaction time and perception, making controls feel more responsive by accommodating how people actually interact with games.
Security & Anti-Cheat Standards
Competitive game features require careful security consideration. Our leaderboard systems implement server-side validation, rate limiting, and input verification—standard practices for any system handling user-submitted data that affects other players.
These approaches don't prevent all cheating, but they make it difficult enough that casual manipulation becomes impractical. We're transparent about both what our systems can protect against and their limitations, because understanding the actual security landscape helps with realistic planning.
Continuous Learning & Improvement
Game development evolves continuously as new techniques emerge and platforms change. We stay current through active participation in Wellington's game development community, regular attendance at conferences like GDC (via online resources), and ongoing experimentation with new tools and approaches. Each project teaches something that improves our methodology for future work.
Where Conventional Development Often Struggles
Common Challenges
Late-Stage Discovery
Building complete features before testing them often reveals fundamental problems only after significant development time. Waiting until "everything is ready" to get feedback wastes resources on approaches that need major revision.
Communication Gaps
Infrequent updates and unclear technical explanations leave clients uncertain about progress and unable to provide meaningful feedback until late in development when changes become expensive.
Technical Over-Engineering
Building systems for hypothetical future features adds complexity that may never provide value. "Flexible" architectures can become confusing labyrinths that slow down simple changes.
Our Approach Addresses These
Early & Continuous Testing
Regular playtesting throughout development catches issues when they're still easy to fix. You see progress incrementally rather than in large reveals, allowing for course corrections before significant resources are committed.
Clear, Regular Updates
Weekly check-ins with working builds keep everyone aligned. Technical decisions get explained in plain language, and concerns get addressed through dialogue rather than after problems emerge.
Build What's Needed
Systems get designed for current requirements with consideration for likely future needs. This balance provides flexibility where it matters while keeping the codebase understandable and maintainable.
These aren't criticisms of other developers—they're common challenges in the industry that our methodology specifically addresses through iterative process and clear communication.
What Makes The Rimewood Approach Distinctive
Feel-First Development
We prioritize how games feel to play over technical specifications. A platformer with "perfect" physics that feels sluggish gets revised until it feels responsive, even if that means deviating from realistic physics. This player-experience focus guides technical decisions rather than letting technical constraints dictate player experience.
Systematic Playtesting Integration
Most developers playtest, but we've integrated it into our core process rather than treating it as a final validation step. Every significant feature gets tested with people who aren't familiar with the project, providing unbiased feedback about whether systems communicate their purpose clearly and feel good to use.
Honest Technical Assessment
We're transparent about technical tradeoffs and limitations. If a feature will be challenging to implement or might not achieve the intended effect, we discuss this during planning rather than discovering it mid-development. This honesty sometimes means recommending simpler approaches, but it prevents wasted effort on approaches unlikely to succeed.
Wellington Community Connection
Being embedded in Wellington's game development community provides continuous learning and diverse perspectives. Local game jams expose us to different design approaches, developer meetups surface emerging techniques, and community playtesting sessions provide access to varied player feedback. This connection keeps our methodology evolving rather than stagnating.
How We Track Progress And Success
During Development: Milestone Tracking
Each project gets broken into specific milestones with clear deliverables. Weekly builds demonstrate progress toward these milestones, making status visible and concrete. If a milestone proves more complex than initially estimated, we discuss adjusted timelines promptly rather than letting schedule slip silently.
Weekly
Build Updates
Bi-weekly
Feature Reviews
Monthly
Milestone Assessments
Playtesting: Qualitative Feedback
Player response provides the clearest measure of whether features work as intended. We track both what players say and what they do—sometimes these differ significantly. A feature players claim to enjoy but rarely engage with needs examination. Similarly, features players struggle to explain but use extensively might need better communication rather than redesign.
Playtesting sessions get documented with notes about player reactions, confusion points, and moments of engagement. These notes guide refinement priorities, ensuring development effort focuses on improvements that matter to actual player experience.
Post-Launch: Performance Metrics
After launch, we track technical performance metrics: frame rates, load times, crash rates, and backend response times. These quantitative measures reveal whether the game performs reliably across different devices and usage patterns.
For features with measurable engagement (like leaderboards or competitive systems), we track usage patterns and player retention around these features. This data informs future development decisions and helps identify areas that might benefit from enhancement.
Success Indicators That Matter
Different projects have different success measures, but these indicators consistently correlate with positive outcomes: Players completing early levels at expected rates suggests good onboarding. Session lengths meeting or exceeding targets indicates engaging core gameplay. Low bug reports and stable performance metrics show technical reliability. Positive player feedback specifically mentioning aspects we focused on validates that our priorities aligned with what players value.
Game Development Methodology Refined Through Experience
The Rimewood methodology developed over five years of arcade and simple game development in Wellington, New Zealand. Our approach combines established game development practices with lessons learned from direct project experience, creating a framework that prioritizes player experience while maintaining technical reliability.
What distinguishes our methodology is integration of continuous playtesting throughout development rather than treating it as final validation. This player-first approach catches usability issues early and validates successful design decisions before significant resources are committed. Regular feedback loops between development and testing accelerate iteration and improve final quality.
Our technical practices follow industry standards for version control, code architecture, and systematic testing. We implement these thoroughly because they work reliably, not because they're innovative. The innovation in our approach comes from how we balance technical execution with player experience design, ensuring neither aspect compromises the other.
Projects range from complete game development including design support to focused feature implementation like leaderboard systems or control refinement. Our methodology scales to project complexity while maintaining core principles of iterative development, clear communication, and player-centered design decisions.
See How This Methodology Works For Your Project
Every project brings unique challenges and requirements. Let's discuss how our player-first, iterative approach might fit your specific needs and goals. Share details about what you're building, and we'll explore realistic options together.
Discuss Your Project