### Node.js Project Setup

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Install project dependencies for a Node.js project.

```bash
# e.g., for a Node.js project: npm install
```

--------------------------------

### Go Project Setup

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Tidy Go module dependencies for a Go project.

```bash
# e.g., for a Go project: go mod tidy
```

--------------------------------

### Manual Verification Plan for Frontend Changes

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

This is an example of a manual verification plan for frontend changes. It includes steps to start the development server, open the application in a browser, and specific UI elements to check.

```markdown
The automated tests have passed. For manual verification, please follow these steps:

**Manual Verification Steps:**
1.  **Start the development server with the command:** `npm run dev`
2.  **Open your browser to:** `http://localhost:3000`
3.  **Confirm that you see:** The new user profile page, with the user's name and email displayed correctly.
```

--------------------------------

### Node.js Daily Development

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Commands for starting the development server, running tests, and linting in a Node.js project.

```bash
# e.g., for a Node.js project: npm run dev, npm test, npm run lint
```

--------------------------------

### Starting a Goroutine in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Shows the basic syntax for launching a new goroutine using the `go` keyword. Goroutines are lightweight, concurrent functions.

```go
go someFunction()
// main function continues execution concurrently
```

--------------------------------

### Run Python Coverage Report

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Example command to run pytest with coverage for a Python application and generate an HTML report. Ensure pytest and the coverage plugin are installed.

```bash
pytest --cov=app --cov-report=html
```

--------------------------------

### Start a New Development Track

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/README.md

Initiate a new feature or bug fix by running this command. It generates detailed specifications and an actionable plan for the track. You can optionally provide a description for the new track.

```bash
/conductor:newTrack
```

```bash
/conductor:newTrack "Add a dark mode toggle to the settings page"
```

--------------------------------

### Install Conductor Extension

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/README.md

Installs the Conductor extension for the Gemini CLI. The --auto-update flag is optional and enables automatic updates to new versions.

```bash
gemini extensions install https://github.com/gemini-cli-extensions/conductor --auto-update

```

--------------------------------

### Manual Verification Plan for Backend Changes

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

This is an example of a manual verification plan for backend changes. It includes steps to ensure the server is running and how to execute a specific API request using curl.

```markdown
The automated tests have passed. For manual verification, please follow these steps:

**Manual Verification Steps:**
1.  **Ensure the server is running.**
2.  **Execute the following command in your terminal:** `curl -X POST http://localhost:8080/api/v1/users -d '{"name": "test"}'`
3.  **Confirm that you receive:** A JSON response with a status of `201 Created`.
```

--------------------------------

### Check Project Status

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/README.md

Use this command to get a high-level overview of your project's progress and the status of ongoing tracks.

```bash
/conductor:status
```

--------------------------------

### C# 'var' Usage Example

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Illustrates the use of 'var' when the type is obvious and explicit type declaration for basic types where it improves clarity.

```csharp
var apple = new Apple();  // Good - type is obvious
```

```csharp
bool success = true;  // Preferred over var for basic types
```

--------------------------------

### C# String Interpolation

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Example of using string interpolation for creating formatted strings, which is generally easier to read than chained concatenations.

```csharp
var message = $"Hello, {name}!";
```

--------------------------------

### Get Latest Commit Hash

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Retrieves the full hash of the most recent commit in the Git repository. This is useful for referencing specific commits.

```bash
git log -1 --format="%H"
```

--------------------------------

### Set Up Project Context with Conductor

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/README.md

Run this command once to define your project's core components, including product details, guidelines, tech stack, and workflow preferences. This sets up the foundational context for future development.

```bash
/conductor:setup
```

--------------------------------

### Creating a Channel in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Demonstrates how to create a channel using `make`. Channels are typed conduits for communication between goroutines.

```go
myChannel := make(chan int)
// myChannel can now be used for communication
```

--------------------------------

### Go Daily Development

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Commands for running the main application, running tests, and formatting code in a Go project.

```bash
# e.g., for a Go project: go run main.go, go test ./..., go fmt ./...
```

--------------------------------

### C# Collection Initializer

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Demonstrates the use of collection initializers for concisely creating and populating collections.

```csharp
var list = new List<int> { 1, 2, 3 };
```

--------------------------------

### Use JSDoc for Documentation and `//` for Implementation Comments

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Utilize `/** JSDoc */` for documentation comments and `//` for inline implementation comments. Avoid redundant type declarations in JSDoc.

```typescript
/**
 * Adds two numbers together.
 * @param a The first number.
 * @param b The second number.
 * @returns The sum of a and b.
 */
function add(a: number, b: number): number {
  // This is an implementation comment.
  return a + b;
}
```

--------------------------------

### Go Pre-commit Checks

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Execute pre-commit checks using a Makefile for a Go project.

```bash
# e.g., for a Go project: make check (if a Makefile exists)
```

--------------------------------

### Importing Modules and Submodules

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Standard practice for importing packages or modules. Use 'from x import y' sparingly, typically for submodules.

```python
import os
from os import path
```

--------------------------------

### Review Completed Work

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/README.md

Run this command to review completed work against project guidelines and the defined plan.

```bash
/conductor:review
```

--------------------------------

### Using defer for Cleanup in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Shows the use of the defer keyword to schedule a function call for execution just before the surrounding function returns. Ideal for cleanup tasks.

```go
defer file.Close()
// other function logic
```

--------------------------------

### Implement a Development Track

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/README.md

Execute this command to have the coding agent work through the tasks defined in the `plan.md` file for the current track. It follows the specified workflow and updates statuses automatically.

```bash
/conductor:implement
```

--------------------------------

### Allocating Memory with new() in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Illustrates using the `new` function to allocate memory for a type, zeroing it, and returning a pointer to it. Use for basic types.

```go
ptr := new(int)
// *ptr is now 0
```

--------------------------------

### Conditional Execution with Initialization in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Demonstrates an if statement that includes an initialization statement. Braces are mandatory, and parentheses around the condition are not used.

```go
if err := file.Chmod(0664); err != nil {
    // handle error
}
```

--------------------------------

### C# Pattern Matching for Type Check

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Shows how to use pattern matching for type checking and casting in a single step, improving code readability.

```csharp
if (obj is string str) { /* use str */ }
```

--------------------------------

### Node.js Pre-commit Checks

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Run all pre-commit checks, including formatting, linting, type checking, and tests, for a Node.js project.

```bash
# e.g., for a Node.js project: npm run check
```

--------------------------------

### Checking for Key Existence in a Map in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Demonstrates the idiomatic "comma ok" pattern to safely check if a key exists in a map and retrieve its value.

```go
value, ok := myMap["someKey"]
if ok {
    // key exists, use value
} else {
    // key does not exist
}
```

--------------------------------

### Run Pylint for Linting

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Use the pylint command-line tool to identify bugs and enforce style consistency in your Python code.

```bash
pylint your_module.py
```

--------------------------------

### Conventional Commit Type: Style

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Use 'style' type for formatting changes.

```bash
git commit -m "style(mobile): Improve button touch targets"
```

--------------------------------

### Iterating Over a Map in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Shows how to use the for...range construct to iterate over a map. This is Go's primary looping mechanism.

```go
for key, value := range myMap {
    // process key and value
}
```

--------------------------------

### Conventional Commit Type: Test

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Use 'test' type for adding tests.

```bash
git commit -m "test(comments): Add tests for emoji reaction limits"
```

--------------------------------

### C# Formatting: Braces and Else

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Demonstrates K&R style brace formatting, requiring braces even when optional and keeping '} else' on a single line.

```csharp
if (condition) {
  DoSomething();
} else {
  DoSomethingElse();
}
```

--------------------------------

### Improve Argument Clarity in C#

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Demonstrates how to refactor code for better argument clarity by using named constants, enums, named arguments, or configuration objects instead of ambiguous boolean or magic number parameters.

```csharp
// Bad
DecimalNumber product = CalculateProduct(values, 7, false, null);

// Good
var options = new ProductOptions { PrecisionDecimals = 7, UseCache = CacheUsage.DontUseCache };
DecimalNumber product = CalculateProduct(values, options, completionDelegate: null);
```

--------------------------------

### Standard Main Function Structure

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Executable Python files should contain a main() function, invoked within an 'if __name__ == "__main__":' block.

```python
def main():
    # Main logic here
    print("Hello, world!")

if __name__ == "__main__":
    main()
```

--------------------------------

### Create Checkpoint Commit

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Stage all changes and create a commit with a clear message to mark the end of a phase. This commit serves as a checkpoint for future reference.

```bash
conductor(checkpoint): Checkpoint end of Phase X
```

--------------------------------

### Using Comprehensions for Simple Cases

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

List comprehensions are suitable for straightforward transformations. Opt for full loops when logic becomes complex for readability.

```python
squares = [x**2 for x in range(10)]
```

--------------------------------

### Multiple Return Values for Result and Error in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Demonstrates a common Go pattern where a function returns both a result and an error. Named result parameters can enhance clarity.

```go
value, err := someFunction()
if err != nil {
    // handle error
}
```

--------------------------------

### Conventional Commit Type: Feature

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Use 'feat' type for new features.

```bash
git commit -m "feat(auth): Add remember me functionality"
```

--------------------------------

### Using Switch Without an Expression in Go

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/go.md

Illustrates using a switch statement without an expression, functioning as a cleaner if-else-if chain. Cases do not fall through by default.

```go
switch {
case condition1:
    // handle condition1
case condition2:
    // handle condition2
default:
    // handle default case
}
```

--------------------------------

### Append Checkpoint SHA to Plan

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Update the `plan.md` file by appending the checkpoint SHA to the relevant phase heading. This provides an auditable link between the plan and the code.

```markdown
[checkpoint: <sha>]
```

--------------------------------

### Handling Exceptions Safely

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Avoid bare 'except:' clauses. Use specific built-in exception classes for clearer error handling.

```python
try:
    # Code that might raise an exception
    pass
except ValueError:
    # Handle ValueError specifically
    pass
```

--------------------------------

### TODO Comment Format

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Use the specified format for TODO comments, including the username responsible for the task.

```python
# TODO(username): Fix this bug in the next sprint.
```

--------------------------------

### Conventional Commit Message Format

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Standard format for commit messages, including type, scope, description, and optional body/footer.

```bash
<type>(<scope>): <description>

[optional body]

[optional footer]
```

--------------------------------

### Using F-strings for String Formatting

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Employ f-strings for efficient and readable string formatting in Python 3.6+.

```python
name = "Alice"
age = 30
print(f"Name: {name}, Age: {age}")
```

--------------------------------

### Defining Module-Level Constants

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Constants intended for module-level use should be named using ALL_CAPS_WITH_UNDERSCORES.

```python
MAX_CONNECTIONS = 10
```

--------------------------------

### CSS Class Naming Convention

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Use meaningful, generic class names with words separated by hyphens. Avoid abbreviations.

```css
.video-player
```

```css
.site-navigation
```

--------------------------------

### Do Not Use Wrapper Objects

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Instantiate primitive types directly instead of using `String`, `Boolean`, or `Number` wrapper classes.

```typescript
// Avoid:
const str = new String('hello');
const bool = new Boolean(true);

// Prefer:
const str = 'hello';
const bool = true;
```

--------------------------------

### List Changed Files in a Git Phase

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Use this command to identify all files modified during a specific Git phase, based on the previous checkpoint SHA. This is crucial for verifying test coverage.

```bash
git diff --name-only <previous_checkpoint_sha> HEAD
```

--------------------------------

### Announce Automated Test Execution Command

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Before running automated tests, announce the exact command to be used. This ensures transparency and aids in debugging if failures occur.

```bash
CI=true npm test
```

--------------------------------

### C# Null-Conditional and Null-Coalescing Operators

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Illustrates the use of null-conditional (?.) and null-coalescing (??) operators to simplify null checks and provide default values.

```csharp
var length = text?.Length ?? 0;
```

--------------------------------

### Conventional Commit Type: Fix

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Use 'fix' type for bug fixes.

```bash
git commit -m "fix(posts): Correct excerpt generation for short posts"
```

--------------------------------

### Checking for None Values

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Use 'is None' for explicit checks against the None singleton, rather than relying on truthiness.

```python
if my_variable is None:
    print('Variable is None')
```

--------------------------------

### Use ES6 Modules for Imports and Exports

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Employ ES6 modules (`import`/`export`) for code organization. Avoid `namespace`. Use named exports (`export {MyClass};`) and do not use default exports.

```typescript
import { MyClass } from './my-class';
export { MyClass };
```

--------------------------------

### HTML Meta Charset Declaration

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Specify UTF-8 encoding for HTML documents without a Byte Order Mark (BOM).

```html
<meta charset="utf-8">
```

--------------------------------

### Prefer Optional Parameters and Fields

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Use optional parameters and fields (`?`) over explicitly adding `|undefined` to the type definition.

```typescript
// Prefer:
function greet(name?: string) {}
interface User { age?: number }

// Avoid:
function greet(name: string | undefined) {}
interface User { age: number | undefined }
```

--------------------------------

### Use Strict Equality Checks

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Always use triple equals (`===`) for equality checks and not equals (`!==`) for inequality checks. Avoid loose equality.

```typescript
if (a === b) {
  // ...
}

if (a !== b) {
  // ...
}
```

--------------------------------

### C# Expression-Bodied Property

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/csharp.md

Shows the use of expression-bodied members for simple properties. Methods should generally prefer block bodies.

```csharp
public int Age => _age;
```

--------------------------------

### Do Not Use `{}` Type

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Avoid using the `{}` type. Prefer `unknown`, `Record<string, unknown>`, or `object` for better type safety.

```typescript
// Avoid:
function processData(data: {}) {}

// Prefer:
function processData(data: unknown) {}
// or
function processData(data: Record<string, unknown>) {}
```

--------------------------------

### Avoid `_` Prefix/Suffix for Identifiers

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Do not use `_` as a prefix or suffix for identifiers, including private properties.

```typescript
// Avoid:
class MyClass {
  private _myPrivateField: string;
}

// Prefer:
class MyClass {
  private myPrivateField: string;
}
```

--------------------------------

### HTML Document Type Declaration

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Always use the HTML5 doctype declaration at the beginning of your HTML documents.

```html
<!doctype html>
```

--------------------------------

### Revert Work

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/README.md

If necessary, use this command to undo a feature or a specific task that has been worked on.

```bash
/conductor:revert
```

--------------------------------

### CSS Hexadecimal Notation

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Use the shorthand 3-character hexadecimal notation for colors when possible.

```css
#fff
```

--------------------------------

### Add Git Note to Commit

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/workflow.md

Attaches a text note to a specific Git commit. The note content is provided via the -m flag, and the commit hash identifies the target commit.

```bash
git notes add -m "<note content>" <commit_hash>
```

--------------------------------

### Avoid `any` Type

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Refrain from using the `any` type. Prefer `unknown` or a more specific type to enhance type safety.

```typescript
// Avoid:
let data: any;

// Prefer:
let data: unknown;
// or
let data: { [key: string]: string };
```

--------------------------------

### Use const or let for Variable Declarations

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Always use `const` or `let` for variable declarations. Prefer `const` by default. `var` is forbidden.

```typescript
const myConstant = 10;
let myVariable = 'hello';
```

--------------------------------

### Use `T[]` for Simple Array Types

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Employ the `T[]` syntax for simple array types. Use `Array<T>` for more complex union types.

```typescript
const simpleArray: number[] = [1, 2, 3];
const complexArray: Array<string | number> = ['a', 1, 'b'];
```

--------------------------------

### Naming Conventions in TypeScript

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Follow standard naming conventions: `UpperCamelCase` for types and classes, `lowerCamelCase` for variables and functions, and `CONSTANT_CASE` for global constants.

```typescript
class MyClass {}
interface MyInterface {}
type MyType = string;
enum MyEnum { Value1, Value2 }

let myVariable: string;
function myFunction() {}

const GLOBAL_CONSTANT = 123;
```

--------------------------------

### Prefer Function Declarations and Arrow Functions

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Use function declarations for named functions and arrow functions for anonymous functions or callbacks.

```typescript
function namedFunction() {
  // ...
}

const arrowFunction = () => {
  // ...
};
```

--------------------------------

### CSS Rule with Space Before Opening Brace

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Include a space between the last selector and the opening curly brace of a CSS rule.

```css
.foo {
```

--------------------------------

### Avoiding Mutable Default Arguments

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/python.md

Do not use mutable objects like lists or dictionaries as default argument values to prevent unexpected side effects.

```python
def add_item(item, item_list=[]):
    # This is discouraged
    item_list.append(item)
    return item_list
```

--------------------------------

### Avoid Type Assertions

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Minimize the use of type assertions (`x as SomeType`) and non-nullability assertions (`y!`). If their use is unavoidable, provide a clear justification.

```typescript
// Avoid this if possible:
const value = someUnknownValue as string;
const nonNullValue = possiblyNullValue!;
```

--------------------------------

### Use Plain `enum` Instead of `const enum`

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Do not use `const enum`. Opt for plain `enum` declarations.

```typescript
// Avoid:
// const enum Color { Red, Green, Blue };

// Prefer:
enum Color { Red, Green, Blue }
```

--------------------------------

### Rely on Type Inference for Simple Types

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Leverage type inference for straightforward types. Be explicit when defining complex types.

```typescript
const inferredNumber = 10; // TypeScript infers number
const inferredString = 'hello'; // TypeScript infers string

const explicitObject: { name: string; age: number } = { name: 'Alice', age: 30 };
```

--------------------------------

### HTML Link Element without Type Attribute

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Omit the 'type' attribute for stylesheet links in HTML.

```html
<link rel="stylesheet" href="style.css">
```

--------------------------------

### CSS Declaration with Zero Unit Omission

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Omit units for zero values in CSS properties like margin or padding.

```css
margin: 0;
```

--------------------------------

### HTML Script Element without Type Attribute

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Omit the 'type' attribute for script tags in HTML.

```html
<script src="script.js"></script>
```

--------------------------------

### Forbidden Features: `eval()` and `Function(...string)`

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

The use of `eval()` and `Function(...string)` is forbidden due to security and performance concerns.

```typescript
// Forbidden:
eval('console.log("hello")');
const func = new Function('a', 'b', 'return a + b');
```

--------------------------------

### CSS Rule with Space After Colon

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Ensure a space follows the colon in CSS property declarations.

```css
font-weight: bold;
```

--------------------------------

### CSS Declaration with Leading Zero

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Always include leading zeros for decimal values in CSS properties like font-size.

```css
font-size: 0.8em;
```

--------------------------------

### Use Single Quotes for String Literals

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Prefer single quotes (`'`) for string literals. Use template literals (`` ` ``) for string interpolation and multi-line strings.

```typescript
const singleQuoted = 'This is a single-quoted string.';
const templateLiteral = `This is a ${singleQuoted} string.`;
```

--------------------------------

### End Statements with Semicolons

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Explicitly terminate all statements with a semicolon to avoid relying on Automatic Semicolon Insertion (ASI).

```typescript
const x = 5;
console.log(x);
```

--------------------------------

### Use TypeScript Visibility Modifiers for Class Properties

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/typescript.md

Do not use `#private` fields. Utilize TypeScript's `private` visibility modifier. Mark properties that are never reassigned outside the constructor with `readonly`. Avoid the `public` modifier as it is the default.

```typescript
class MyClass {
  private myPrivateField: string;
  readonly myReadonlyField: number;

  constructor(privateField: string, readonlyField: number) {
    this.myPrivateField = privateField;
    this.myReadonlyField = readonlyField;
  }
}
```

--------------------------------

### CSS Attribute Selector with Single Quotes

Source: https://github.com/gemini-cli-extensions/conductor/blob/main/templates/code_styleguides/html-css.md

Use single quotes for attribute selectors and property values in CSS.

```css
[type='text']
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.