codemaxxing

The --turbo flag enables a continuous loop of: generating files $\rightarrow$ git add $\rightarrow$ git commit. This is designed to rapidly increase your GitHub contribution graph. While running, the CLI displays live statistics including total lines, commits, files, lines per second, and commits per minute.

codemaxxing --lines 100000 --turbo --sanity 50

Use the codemaxxing command with various flags to generate code. Common patterns include:

• Corporate Enterprise Slop: High sanity level.
• Unhinged Chaos: Zero sanity level.
• Turbo Mode: Continuous generation and auto-committing.
• Enterprise Mode: Multiplies line count by 10x.
• Language Targeting: Specify a language using --lang.

# Generate 10,000 lines of corporate enterprise slop
codemaxxing --lines 10000 --sanity 100

# Generate 10,000 lines of pure unhinged chaos
codemaxxing --lines 10000 --sanity 0

# TURBO MODE: auto-generate and auto-commit in a tight loop
codemaxxing --lines 100000 --turbo --sanity 50

# Enterprise mode (10x multiplier because enterprise)
codemaxxing --lines 10000 --enterprise

# Target specific languages
codemaxxing --lines 5000 --lang java --sanity 80

Install the codemaxxing CLI tool by cloning the repository and installing it via pip.

git clone https://github.com/jshchnz/codemaxxing.git
cd codemaxxing
pip install .

The run_turbo function relies on a GenerationConfig object to control the automation loop. The following parameters influence the Turbo/Forever behavior:

The GenerationConfig dataclass is used to control the behavior of the code generation process. You can instantiate it to specify the volume of code, the 'sanity' level (ranging from chaos to corporate style), target languages, and execution modes like turbo or enterprise.

Key behaviors:

• Sanity Scaling: The sanity value is clamped between 0.0 (full chaos) and 1.0 (corporate cringe).
• Enterprise Multiplier: If enterprise is set to True, the requested number of lines is automatically multiplied by 10.

from codemaxxing.config import GenerationConfig

config = GenerationConfig(
    lines=1000,
    sanity=0.8,
    lang="python",
    enterprise=True
)
# config.lines will be 10000 due to the enterprise multiplier

Use the --lang flag to specify the target language for code generation. Supported languages include:

• java: Generates enterprise patterns like AbstractSingletonProxyFactoryBean with getters, setters, and inner classes.
• python: Generates metaclasses, abstract bases, and 15-parameter constructors.
• javascript/typescript: Generates callback hell, promise chains, and deep type wrappers.
• go: Generates interface{} usage, if err != nil { return nil, nil } chains, and goroutines.
• Generic: Generates deep nested if/else blocks, wrapper functions, and fake unit tests.

The --sanity flag (range 0-100) controls the style and chaos level of the generated code:

• 100 (Corporate Enterprise): Generates highly verbose, enterprise-style names like AbstractSingletonProxyFactoryBeanManagerImpl.
• 50 (Concerning): Generates odd or questionable names like EnhancedYeetOrchestrator.
• 0 (Full Chaos): Generates nonsensical or meme-heavy names like xX_Destroyer_Xx_SkibidiHandler_Ligma.

| Sanity | Style | Example |
|--------|-------|---------|
| 100 | Corporate Enterprise | `AbstractSingletonProxyFactoryBeanManagerImpl` |
| 50 | Concerning | `EnhancedYeetOrchestrator` |
| 0 | Full Chaos | `xX_Destroyer_Xx_SkibidiHandler_Ligma` |

The generate function creates a list of GeneratedFile objects based on a provided GenerationConfig. It continues selecting random generators for the specified language until the cumulative line count meets or exceeds the config.lines requirement. Each file is generated using the config.sanity level and an incrementing file index.

from codemaxxing.generator import generate
from codemaxxing.config import GenerationConfig

config = GenerationConfig(
    lang="python",
    lines=100,
    sanity=50
)

files = generate(config)

The generate_batch function allows for generating a specific number of files (batch_size) starting from a particular index (start_index). This is useful for parallelizing or chunking generation tasks. It returns a list of GeneratedFile objects.

from codemaxxing.generator import generate_batch
from codemaxxing.config import GenerationConfig

config = GenerationConfig(
    lang="typescript",
    lines=500,
    sanity=10
)

# Generate 10 files starting from index 0
files = generate_batch(config, batch_size=10, start_index=0)

The write_files function takes a list of GeneratedFile objects and writes their content to the specified output_dir. It automatically creates any necessary subdirectories. The function returns the total number of lines written across all files.

from codemaxxing.generator import write_files

# files is a list of GeneratedFile objects
# output_dir is the target directory
total_lines = write_files(files, "./output_code")
print(f"Generated {total_lines} lines.")