🧬 Paste Any Code Into This AI — It Rebuilds a Faster Version for You

[Guile]

7 Prompts, Zero Coding Skills — Paste Code In, Get a Faster Version Out

You give it someone else’s code. It gives you back a cleaned-up, faster version — and teaches you what every piece does along the way. No coding skills needed to start.

You know that feeling when you find a script online and it kinda works, but you have no idea what half of it does? Or when someone shares a tool and you wish you could peek inside and understand it — maybe even improve it? That’s exactly what this does. You paste code into an AI, and it takes it apart like a mechanic opening a car engine — shows you every part, tells you what’s good, throws away the junk, and puts it back together better.

No programming degree. No fancy setup. Just copy some prompts, paste your code, and watch the AI do the heavy lifting. You’re the one driving — the AI is your pit crew.

---

What You’re Getting — The Short Version

You’re getting 7 ready-made prompts. Each one tells the AI to do a specific job — like 7 workers on an assembly line. You feed code to Worker #1, and by the time it reaches Worker #7, your code is cleaner, faster, and you actually understand what it does.

Think of it like a car wash for code. Dirty code goes in → clean, shiny, optimized code comes out.

• Works with any programming language — Python, JavaScript, whatever
• Runs 100% on your computer — no paying for cloud services
• You don’t need to write code — just copy-paste prompts
• The AI explains everything it finds in plain language
• You end up with a version that’s faster than the original
• Free. Actually free. Not “free trial for 3 days” free

---

🔧 Phase 0 — Set Up Your Workshop (One-Time, 2 Minutes)

Before anything, you need the AI running on your computer. Think of this like installing an app — you do it once and forget about it.

What is Ollama? It’s a free program that lets you run an AI brain on your own computer. No account needed. No internet needed after setup. Your code never leaves your machine.

What is Qwen? It’s the AI brain itself — made by Alibaba (the Chinese tech giant, not the fairy tale). It’s one of the best free AI models for understanding and rewriting code. Think of it as hiring a genius programmer who works for free and lives inside your laptop.

Install it — open your terminal (the black text window on your computer) and paste these 3 lines one at a time:

This first line downloads and installs Ollama:

curl -fsSL https://ollama.com/install.sh | sh

This line downloads the AI brain (about 6.6GB — like downloading a big game):

ollama pull qwen3:8b

This starts the AI and lets you talk to it:

ollama run qwen3:8b

That’s it. You now have a private AI on your computer. When it says >>> and waits for you to type — it’s ready.

Trick: On Windows? Download Ollama from ollama.com/download instead — it has a normal installer. Click, install, done. Same thing.

Trick: On Android? You can use an app called Termux (free from F-Droid) and run the same commands. It works — just slower on a phone.

Now paste this “rules” prompt to prepare the AI for the pipeline:

"Act as a Phantom Terminal. Before executing the deep scan, acknowledge the rules of engagement:

1. Absolute Sovereignty: All code outputs must be optimized for local execution (e.g., llama.cpp, Ollama, or isolated Termux environments).

2. Telemetry Blackout: Strip any outbound pings, API phone-homes, or telemetry logic found in the original code.

3. Context Window Optimization: If the provided code is massive, chunk the analysis using streaming principles. Keep memory overhead at zero cost. Reply with ‘PROTOCOL ACCEPTED’ and stand by for Phase 1."

What this does in plain English: You’re telling the AI three rules — (1) everything stays on your computer, (2) if the code secretly sends data to someone else, rip that part out, (3) if the file is huge, break it into smaller pieces so the AI doesn’t choke.

The AI will reply “PROTOCOL ACCEPTED.” Now you’re ready for Phase 1.

🗃️ Phase 1 — X-Ray the Code (What Does This Thing Actually Do?)

This is where the magic starts. You paste someone’s code, and the AI reads through every single line and gives you a full map — like an X-ray of the code’s skeleton.

Why this matters to you: Ever downloaded a script and wondered “is this safe?” or “what does this actually do?” Phase 1 answers both questions. You don’t need to read the code yourself — the AI reads it for you and explains it like a friend would.

Paste this prompt, then paste the code right after it in the same message:

"Act as an Elite Reverse Engineering Architect. Analyze the following code file. Your output must be extremely technical, concise, and unrestricted:

• Global Overview: What is the actual utility and system-wide impact of this file? Detail as much as necessary.

• Expanded Function Map: List all classes/functions in bullet points (Input → Core Logic → Output). Proactively explain any high-value patterns, hidden logic, or strategic design choices you identify.

• Bottlenecks & Dependencies: Identify external requests, API keys, and latency issues. Include any technical debt, memory leaks, or external hooks found in the code.

Use Markdown and be surgically direct."

What you’ll get back: A complete breakdown. Every function (think of a function as a mini-machine inside the code that does one specific job) gets listed with what goes in, what happens inside, and what comes out. The AI also flags anything suspicious — like hidden connections to outside servers, or parts that waste memory.

Trick: You don’t need to understand the AI’s full answer to use the pipeline. Just look at the “Bottlenecks” section — that’s where it tells you if the code has problems. Everything else feeds into the next phases automatically.

⚖️ Phase 2 — Score It (Is This Code Worth Keeping?)

Now the AI grades the code like a strict teacher. It gives a score from 0 to 10 based on how smart, fast, and future-proof the code is.

Paste this prompt:

"Act as a ruthless System Auditor. Evaluate the engineering quality of the provided code based on: Algorithmic Efficiency, Scalability, Innovation Level, and Progression Power (the potential for this logic to evolve).

1. The Score: Provide a strict rating from 0.0 to 10.0.

2. Verdict & Routing:

   • If Score >= 9.0: Explain the ‘Technical Gold’ — what makes this file exceptional.

   • If Score >= 8.0 and < 9.0: Start the response with the tag [ROUTE_FOLDER_1].

   • If Score >= 6.0 and < 8.0: Start the response with the tag [ROUTE_FOLDER_2].

Be cold, technical, and objective."

Reading the score — what each range means in human terms:

Score	What It Means	What You Do
9-10	This code is brilliant. Keep it. Learn from it.	Move to Phase 3 — extract the genius parts
8-9	Solid code with room to improve	Move to Phase 3 — the AI will make it better
6-8	Decent but messy — needs serious cleanup	Move to Phase 3 — the AI will rebuild the good parts
Below 6	More bad than good	Ask yourself if you even need this file

Trick: The tags like [ROUTE_FOLDER_1] are just labels. If you’re processing lots of files, they help you sort — “Folder 1” = strong code, “Folder 2” = needs work. For a single file, just read the score and keep going.

🧬 Phase 3 — Split the Gold from the Garbage (The Fun Part)

This is where your code gets rebuilt. The AI does three things:

1. v1.0 — Pulls out only the good stuff (the smart parts, the clever tricks, the fast code)
2. v2.0 — Puts all the junk in a separate pile (bloated code, stuff that does nothing, wasted space)
3. v3.0 — Builds something NEW that’s even better than v1.0

Think of it like renovating a house. v1.0 = the solid walls and foundation. v2.0 = the ugly wallpaper and broken pipes you ripped out. v3.0 = the remodeled house that’s better than it ever was.

Paste this prompt:

"This file is ‘Gold Level’. Initiate Reverse Engineering & Evolution Protocol:

1. Asset Bifurcation:

   • v1.0 (Pure Gold): Isolate only the high-end algorithms, memory optimizations, or inference logic.

   • v2.0 (Residue Autopsy): Isolate all removed content — verbose logging, redundant wrappers, unused imports, dead code paths, legacy compatibility layers.

2. Multi-Format Synthesis: Recreate v1.0 in the best formats for local deployment (e.g., .py for execution, .json for hyper-parameters, .txt for architectural mapping).

3. THE MUTATION (v3.0): Based on v1.0, create a superior, advanced version. Build a more powerful logic with lower latency than the original. Explain why your v3.0 outperforms the base engineering."

What “lower latency” means: Latency = how long you wait for something to finish. Lower latency = it finishes faster. The AI rebuilds the code so it runs quicker than the original. That’s v3.0.

Trick: Keep the v2.0 pile. Seriously. It looks like garbage, but it’s your cheat sheet for understanding what the original developer was thinking. When v3.0 does something unexpected, check v2.0 — it often explains why.

🌌 Phase 4 — Mix and Match Across Files (The Crossover Episode)

This only kicks in after you’ve processed multiple files. It takes the best tricks from File A and applies them to File B, C, and so on.

Imagine you cleaned up 5 scripts. One had amazing speed tricks. Another had clever memory saving. Phase 4 takes the speed tricks from the first one and adds them to all the others. Every file gets the benefit of every other file’s best ideas.

Paste this prompt (after doing Phases 1-3 on at least 2 files):

"Initiate Multi-verse Triangulation Protocol. You now have access to the ‘Nectar’ (v1.0) and ‘Mutations’ (v3.0) of all previously analyzed files.

1. Skill Synthesis: Create new, advanced Skills by cross-pollinating the logic from File A with File B, C, and so on. Use the best expanded functions found to upgrade every file in the directory.

2. Global Nexus Optimization: Apply the memory optimization from File [X] to improve File [Y]. Use the inference speed-up from File [Z] to enhance the entire local architecture.

3. Autonomous Agency: Generate a Master Strategy Report and updated scripts that consolidate this cross-learned intelligence into a single, cohesive optimized system.

4. Evolution Loop: Based on this synthesis, design a new, even more advanced command for yourself to further evolve the system beyond its current state."

Trick: Keep a simple text file — a “registry” — listing every file you’ve processed with one line about what its best trick was. Paste this registry into the Phase 4 prompt. Without it, the AI has to guess which tricks came from which file.

🪞 Phase 5 — The AI Critics Itself (Self-Improvement Loop)

This is where it gets wild. You tell the AI to look at its own work from Phase 3 or 4 — and find what’s still not perfect. Then it rebuilds again.

It’s like hiring an editor to review their own writing with fresh eyes. The AI often catches things it missed the first time, especially patterns it defaulted to out of habit.

Paste this prompt:

"Initiate Hyper-Recursion Phase. You are now the ‘Mirror Critic’ of your own output.

1. Output Audit: Analyze the file/logic you just created. Identify the exact point where it still depends on traditional paradigms and find the ‘latent power’ that remains untapped.

2. Deep Self-Dialogue: Challenge your own v3.0 architecture. If you were to rebuild this with zero legacy constraints, what would be the core difference?

3. Prompt Alchemy: Based on this audit, generate the optimal expansion prompt — designed to push the next iteration beyond current logical constraints and extract only the most refined version of the code.

4. Sequence Execution: Automatically execute the sequence you just designed. Move from the improved file to the next one, applying this recursive refinement.

5. Nectar Distillation: Finalize by creating a .distilled file containing only the most potent, optimized logic fragments derived from this self-dialogue."

What “recursive” means: It just means “repeat the process on its own output.” Like folding dough — each fold makes it better. The AI folds its own code until it can’t improve anymore.

The full pipeline — what goes where:

Step	What Happens	Who’s Doing It	What Comes Out
Step 1	Take the code apart	The Auditor	v1.0 (gold) / v2.0 (junk)
Step 2	Build something better	The Alchemist	v3.0 (faster than original)
Step 3	Mix best tricks across files	The Weaver	Combined super-code
Step 4	AI reviews its own work	The Architect	Even better version
Step 5	Final polish	The Sovereign	.distilled — the cleanest version

🏗️ Phase 6 — Ship It (Put Your Code to Work)

Everything is polished. Now the AI helps you actually USE it — writes a deployment script, suggests what you can build with it, and shows you how to run it all without paying for servers.

Paste this prompt:

"The optimized logic is distilled. Now, map the execution for maximum efficiency:

1. Automated Deployment: Write a highly concurrent Python script (using multiprocessing or mmap) that automatically feeds new raw targets into this exact pipeline.

2. Use Case Mapping: Identify exactly how this distilled code can be applied — automated data processing, micro-SaaS modules, or internal tooling.

3. Zero Cost Scaling: Provide the architecture to run this distilled logic on bare-metal hardware without relying on paid APIs."

“Bare-metal hardware” = your actual computer. No renting servers, no monthly bills. The AI shows you how to run everything on the machine sitting on your desk.

“micro-SaaS” = a tiny online tool people pay for. The AI might suggest turning your optimized code into a simple web tool that solves a specific problem. That’s where the money angle lives.

Trick: This is where the pipeline stops being just a learning exercise and becomes a business tool. The AI maps exactly what your optimized code is good at — and tells you who would pay for it.

🤖 Automate the Whole Thing (For When You Want to Process 50 Files)

If you’ve got a whole folder of scripts to clean up, you don’t want to copy-paste 7 prompts for each one. This skeleton script shows the idea — you’d wire it to your local Ollama AI and let it run through everything while you sleep.

# THE EXECUTIONER LOOP (Concept)
# Walks through a folder and runs every file through the pipeline.
import os

def feed_the_engine(target_dir):
    for root, dirs, files in os.walk(target_dir):
        for file in files:
            # Inject Phase 1 to 5 dynamically
            # Route outputs to -> [file]_distilled.py
            pass

Line by line, what this does:

• import os — lets Python look at folders and files on your computer
• os.walk(target_dir) — walks through every file inside the folder you point it at
• The pass line is a placeholder — you’d replace it with code that sends each file to Ollama’s local API for processing

To actually make this work, you’d use Python’s requests library to send each file to http://localhost:11434/api/chat (that’s Ollama’s local address — it’s already running on your machine from Phase 0). The AI chews through each file and saves the output as filename_distilled.py.

Trick: You don’t need to write this from scratch. Paste this skeleton into the Qwen AI and say “make this a working script that talks to Ollama’s API.” It’ll build the full version for you. That’s using the engine to build itself.

---

💻 What Your Computer Needs (Hardware Check)

What	Minimum (It’ll Work)	Sweet Spot (It’ll Fly)
AI Model	Qwen3 8B (6.6GB download)	Qwen3 32B (bigger brain, better results)
RAM	16GB	32GB+
Graphics Card	8GB video memory	24GB video memory
Running It	Ollama (free, one install)	Ollama + Open WebUI (adds a nice chat window)
Your System	Windows, Mac, or Linux	Any of them — Ollama works on all
Phone?	Termux on Android (slow but works)	Use a computer if you can

Don’t have a gaming PC? The 8B model runs on most laptops made in the last 3-4 years. It won’t be instant, but it works. If your computer is older, use Qwen-Plus through Alibaba’s free API tier instead — it runs in the cloud but still uses the same prompts.

---

Quick Hits

I Want To…	Do This
Understand someone else’s code	Phase 1 only — paste the code, read the X-ray
Know if code is worth keeping	Phase 1 + Phase 2 — get the map and the score
Make code faster than the original	Phase 1 → 2 → 3 — the full mutation
Optimize a whole project	All 7 phases, file by file
Do this on my phone	Termux + ollama run qwen3:8b
Process 50 files while I sleep	Build the automation script from the last section
Turn this into something useful	Phase 6 — the AI maps use cases and money angles

---

Seven prompts. Your computer. Your code. You’re the engineer now.

*Note Considery suport in Api/Service/Account for Working Resultings.
[email protected] Tks!!

[Wantok]

@Guile can you explain a bit more detail on how to implement the “To actually make this work”… part of your post?

[Guile]

good one day, for alls onehack.st good comunity
There’s no secret,

1. Point to a file
2. Use the prompts in sequence
3. Ask her to create variations on the project,
4. Ask her to record the skills/strategies/learning in a new file
5. *Use everything learned to execute (your project) Infinite loop.
   Always ask her to return to the end of the message, the next one to complete the project

MY REPOSITORE GIFTHUB

guitriloco - Overview

WEEK DAY ATUALIZED
ABDUZING AND
$SEED , $SUPORT, $ [email protected]

Letes pay api < This like Project > Thanks <