skills.rest
yeisme
yeismeCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

go-rust-implementation-defaults

Choose TypeScript/Bun, Go, Rust, or native packages for Yeisme capabilities.

Updated Jun 5, 2026
Search Tags:#TypeScript#Rust#Go#backend architecture#language implementation
One-click install
npx skills add https://github.com/yeisme/pinax --skill go-rust-implementation-defaults
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: go-rust-implementation-defaults
Source: https://github.com/yeisme/pinax/tree/main/.agents/skills/go-rust-implementation-defaults
Command: npx skills add https://github.com/yeisme/pinax --skill go-rust-implementation-defaults

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps decide whether a Yeisme capability should be implemented in TypeScript/Bun, consume a prebuilt native package, or use Go/Rust for backend/system components, ensuring the right language is chosen for each use case.

Core Features & Use Cases

  • Language Decision: Evaluates whether to use TypeScript/Bun, Go, Rust, or a prebuilt native package based on the project's needs.
  • Default Policy: Provides a default policy for language choice, emphasizing the importance of starting with the main language and escalating only when necessary.
  • Cohors Rule: Specific guidelines for Cohors implementation, focusing on TypeScript/Bun for the mainline, with optional native package integration and limited Go/Rust use for separate services.
  • Decision Checklist: A comprehensive checklist to determine when a capability should be moved to Go/Rust/native code.

Quick Start

Review the implementation plan for a new Yeisme capability using the go-rust-implementation-defaults skill.

Frequently Asked Questions about go-rust-implementation-defaults

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I choose between TypeScript, Go, and Rust for backend architecture?▼

Choosing between TypeScript, Go, and Rust for backend architecture depends on evaluating performance needs, system boundaries, and distribution requirements against your project's main language to determine if escalation is necessary.

When should I move a capability from TypeScript to native Go or Rust code?▼

You should move a capability from TypeScript to native Go or Rust code when project needs exceed mainline performance limits, requiring a comprehensive decision checklist to justify the architectural shift for specific system services.

What is the default policy for language implementation in backend projects?▼

The default policy for language implementation emphasizes starting with your main language like TypeScript/Bun and escalating to Go or Rust only when necessary based on specific performance and system boundary requirements.

Should I use prebuilt native packages or write Rust code for system components?▼

Using prebuilt native packages is preferred over writing Rust code when your system components need optimized performance without leaving your main TypeScript/Bun workflow, reserving Rust strictly for separate service implementations.

Can I implement all system boundaries in Go without using TypeScript?▼

Implementing all system boundaries in Go without TypeScript is discouraged; the Cohors rule prioritizes TypeScript/Bun for the mainline, allowing Go only for limited separate services where strict system boundaries demand it.

Related Skills

Explore More Software Engineering Skills→
LerianStudioLerianStudio
205

pre-dev-prd-creation

Generate a complete PRD with problem discovery, user stories, and success metrics.

Official
Basic
nirajrathod19nirajrathod19

package-management

Install and manage language packages, runtimes, and system dependencies via Nix.

Community
Intermediate
bughqbughq
2

stacks-dashboard

Configure Stacks framework admin dashboards with TypeScript and Bun.

Official
Advanced
paimlpaiml
161

Multi-Language Project Analysis with PMAT

Analyze polyglot codebases to detect languages, assess distribution, and generate per-language reports.

Official
Advanced