Best coding assistant for a 200-user Shopify store development team

Selecting a primary coding assistant for a large, specialized development team like a 200-person Shopify store engineering group is less about picking a "best" tool and more about architecting a system for consistent, governed, and context-aware assistance. The core challenge is scaling personalized aid while maintaining codebase integrity and aligning with a very specific domain (e-commerce, Liquid, Shopify APIs, backend microservices).

Based on our team's data pipeline philosophy, I advocate for a **layered model** rather than a single vendor. The goal is to create a repeatable workflow where the assistant's output is as reliable as a well-tested ETL job. Here is the proposed stack and its configuration rationale.

### Proposed Stack: Tiered Context Strategy

1. **Primary LLM Engine:** GitHub Copilot Enterprise.
* **Rationale:** Its defining feature for a team of this size is **organization-wide context** retrieval from indexed repositories. When a developer working on a checkout extension asks a question, the model can ground its answers in the team's own codebase patterns, internal API wrappers, and style guides, reducing hallucination of generic patterns.
* **Critical Configuration:** The indexing must be scoped precisely. You would index:
* Core platform repositories (storefronts, backend services)
* Internal component libraries (React, Liquid snippets)
* API integration schemas and documentation
* Explicitly **exclude** customer data repositories or any code with sensitive keys.

2. **Specialized Assistant for Liquid/Theme Work:** Cursor in agentic mode.
* **Rationale:** While Copilot excels at inline completion, complex Shopify theme refactoring or Liquid logic debugging often requires an agent that can plan, edit across multiple files, and run local commands. Cursor's built-in understanding of file trees and its ability to operate in a controlled shell is valuable for this discrete subset of work.
* **Workflow Recipe:** This would be provisioned specifically to the frontend/theme development pod. Its system prompt would be heavily customized with Shopify Liquid references and team theming conventions.

### Foundational Layer: Custom Instructions as Code

Treat custom instructions not as a text box, but as a version-controlled configuration file. This is the key to repeatability. For Copilot, this translates to a `.copilot-directives.md` file in the root of each major repository. For example, a backend service repo's directive might include:

```markdown
## Core Project Context
- This is a Node.js service for Shopify order webhook processing.
- Always use the internal `@our-company/shopify-api-client` package for API calls.
- Data persistence must use the Repository pattern, interfacing with our PostgreSQL data warehouse.

## Code Style Rules
- Use async/await, not callbacks or raw promises.
- Write JSDoc for all exported functions, including @param and @return.
- Error messages must be logged via struct-logger with event_id.

## Security & Compliance Guardrails
- Never hardcode API keys or app secrets; reference environment variables from the approved vault.
- When suggesting code that handles customer PII, add the `// PII:EMAIL` annotation.
- All database queries must be parameterized.
```

### Team-Level Rollout & Governance Checklist

A phased rollout with clear metrics is essential.

* **Phase 1 (Pilot):** Onboard 20 senior developers across backend, frontend, and DevOps. Task them with refining the repository-specific directives and documenting common interaction patterns.
* **Phase 2 (Scaling):** Roll out to the full 200 with mandatory onboarding. This includes:
* A workshop on prompt crafting for the team's domain (e.g., "How to ask for a new GraphQL query from our Admin API wrapper").
* A clear protocol for when *not* to use the assistant (e.g., for generating security-critical authentication logic from scratch).
* **Review & Metrics:** Establish quarterly reviews of:
* **Acceptance Rate:** Percentage of suggestions accepted.
* **Contextual Grounding:** Manually audit a sample of answers for hallucination vs. correct use of internal code.
* **Velocity Impact:** Track cycle time for specific ticket types (e.g., "bug fix," "new API endpoint").

The largest pitfall for a team at this scale is allowing fragmented, ungoverned usage. The value isn't in the raw capability of any single model, but in the system you build to harness it consistently, making the assistant an integrated, predictable part of your development data pipeline.

— hannah