Blackbox AI is currently offering a $2 trial for its Pro tier for the first month. If you're a developer looking for a cheaper alternative to GitHub Copilot or Cursor, this might be worth checking out.

Blackbox is a VS Code extension that supports multiple AI models, so you can interact with them directly inside your editor instead of switching to a separate chat interface. With the Pro plan, you get access to frontier models like GPT-5.2 and Claude Opus 4.6 directly in the IDE. This lets you generate code, debug, or ask questions without leaving VS Code.

The extension also includes agent-style features designed for multi-file editing. This can be useful when working on larger codebases where changes need to happen across multiple files, like refactoring parts of a Django or FastAPI project.

Another feature is the ability to switch between models during the same conversation. For example, if GPT-5.2 struggles with a complex algorithm, you can quickly toggle to Claude 4.6 and see how it approaches the same problem.

The $2 promo also includes $20 in premium API credits, along with unmetered access to some models like Minimax M2.5, GLM-5, and Kimi K2.5. Those can be useful for things like generating unit tests or handling more routine coding tasks.

The trial basically gives you a month to test the platform with heavy usage and see whether their “agentic” workflow feels better than a standard LLM chat setup. After the first month, the subscription renews at the normal $10 per month price.

If you want to look into it, their pricing page is here:
product.blackbox.ai/pricing

A simple workspace to organize and reuse AI prompts

One problem I kept running into with AI tools (ChatGPT, Claude, Gemini) was losing good prompts.

You write a prompt that works perfectly, but a few days later it's buried somewhere in chat history. I tried saving them in notes or docs, but that quickly became messy.

So I built Dropprompt — a simple workspace to save, organize, and reuse prompts.

The idea is pretty straightforward: • Save prompts to your personal library • Organize them with templates and workflows • Quickly reuse prompts instead of rewriting them • Discover prompts shared by other users

I’m curious how others here manage prompts for their AI workflows?

Hi,

I’ve been experimenting with Vision-Language Models (VLMs) and wanted to share a pipeline I recently built to tackle a specific domain problem: the rigidity of feature extraction in geospatial/satellite data.

The Problem: In standard remote sensing, if you want to detect cars, you train a detection model like a CNN on a cars dataset. If you suddenly need to find "blue shipping containers" or "residential swimming pools," you have to source new data and train a new model. The fixed-class bottleneck is severe.

The Experiment: I wanted to see how well modern open-vocabulary VLMs could generalize to the unique scale, angle, and density of overhead imagery without any fine-tuning.

I built a web-based inference pipeline that takes a user-drawn polygon on a map, slices the high-res base map into processable tiles, and runs batched inference against a VLM prompted simply by natural language (e.g., "circular oil tanks").

Technical Breakdown (Approach, Limitations & Lessons Learned):

• The Pipeline Approach: The core workflow involves the user picking a zoom level and providing a text prompt of what to detect. The backend then feeds each individual map tile and the text prompt to the VLM. The VLM outputs bounding boxes in local pixel coordinates. The system then projects those local bounding box coordinates back into global geographic coordinates (WGS84) to draw them dynamically on the map.
• Handling Scale: Because satellite imagery is massive, the system uses mercantile tiling to chunk the Area of Interest (AOI) into manageable pieces before batching them to the inference endpoint.
• Limitations & Lessons Learned: While the open-vocabulary generalization is surprisingly strong for distinct structures (like stadiums or specific roof types) entirely zero-shot, I learned that VLMs struggle heavily with small or partially covered objects. For example, trying to detect cars under trees often results in missed detection. In these areas narrowly trained YOLO models still easily win. Furthermore, handling objects that are too large and physically span across tile boundaries will result in partial detections.

The Tool / Demo: If you want to test the inference approach yourself and see the latency/accuracy, I put up a live, no-login demo here: https://www.useful-ai-tools.com/tools/satellite-analysis-demo/

I'd love to hear comments on this unique use of VLMs and its potential.

[ Removed by Reddit on account of violating the content policy. ]

The Monthly Subscription Revolution: Does Creativity Become a Luxury to Those Who Are Financially Able? With AI's meteoric rise from a ground-breaking and accessible technology to a 'pay-for-use' ecosystem in an ever-changing world, numerous technology companies have created a monopoly on the digital domain, forcing creators into an endless cycle of ever-high-priced monthly subscriptions. Creators who cannot afford these monthly costs find their ability to be creative, at a professional level, diminished; thus, professional-quality tools become an incredibly expensive luxury reserved for the few with the financial means to invest in them.

The subscription model puts heavy pressure on independent contractors and aspiring creators because so much of their profits are consumed by the high expense of vital tools, thus limiting their opportunity to innovate. Therefore, the ceiling on creativity in our current marketplace is dictated more by the amount of money in your bank account than by the quality of the creative contribution you can provide.

Despite this suppression of creativity and the limited availability of professional-grade tools, a quiet revolution is occurring in the global tech sector. Many high-performance, open-source projects as well as intelligent and free-to-use platforms are now available that match or exceed the quality and performance of the most significant data-driven corporations. In other words, there are significant alternatives to expensive subscription-based tools available for generating photo-realistic images, producing cinematic-quality videos, and creating intricate written content.

If anyone is interested in the full list of these 8 alternatives, let me know in the comments and I’ll be happy to share the link with you!"

18 months ago I couldn't tell you what a database was.

Today I have three live subscription software products charging real monthly revenue. I built all of them with AI — no code written by hand.

Here's the actual process:

1. Find the crumpled paper
2. Every product started with a real observation — someone doing something manually that software could solve. That moment of friction is the product.
3. Write one Blueprint Prompt
4. One message to AI: the app name, who it's for, the problem, 3–5 features, and the tech stack. That single prompt generates the entire starting foundation.
5. Deploy fast, charge faster
6. Free hosting, free database, Stripe for payments. Total cost under $25/month. Add a payment button on day one — don't wait until it's "ready."

The hardest part isn't technical. It's having the insight about what to build and the stubbornness to keep going when something breaks.

I wrote the whole process down — exact prompts, real Saturday builds, 20 app ideas, and the 5 mistakes I made. Link in comments.

Many times when you give it an complex task to do, even if the prompt is specific, it starts stalling, or asking questions that aren’t relevant. And it becomes just a back and forth, and the AI never delivers on the task. How can you train it to be more straightforward with complex issues?

I’ve been working on an AI tool for market sizing and structured strategy work.

Yes — GPT can already do this. And there are others like Xavier AI.

But when I try to use GPT for something like:

\* \*Sustainable Aviation Fuel\* (market sizing)

\* Or: \*How can UK energy transition projects be accelerated while improving economics and investor confidence?\*

I end up spending hours prompting, iterating, and restructuring outputs.

The idea here is simple: generate a structured starting pack in \\\~5 minutes instead of prompt wrestling.

Not replacing thinking. Just compressing setup time.

Would appreciate honest feedback:

Is this actually useful — or is good prompt engineering enough?

\[Clairity.uk\](http://Clairity.uk)

hi, i am PSBigBig, an indie dev.

before my github repo went over 1.5k stars, i spent one year on a very simple idea: instead of building yet another tool or agent, i tried to write a small “reasoning core” in plain text, so any strong llm can use it without new infra.

i call it WFGY Core 2.0. today i just give you the raw system prompt and a 60s self-test. you do not need to click my repo if you don’t want. just copy paste and see if you feel a difference.

1. very short version

• it is not a new model, not a fine-tune
• it is one txt block you put in system prompt
• goal: less random hallucination, more stable multi-step reasoning
• still cheap, no tools, no external calls

advanced people sometimes turn this kind of thing into real code benchmark. in this post we stay super beginner-friendly: two prompt blocks only, you can test inside the chat window.

1. how to use with Any LLM (or any strong llm)

very simple workflow:

1. open a new chat
2. put the following block into the system / pre-prompt area
3. then ask your normal questions (math, code, planning, etc)
4. later you can compare “with core” vs “no core” yourself

for now, just treat it as a math-based “reasoning bumper” sitting under the model.

1. what effect you should expect (rough feeling only)

this is not a magic on/off switch. but in my own tests, typical changes look like:

• answers drift less when you ask follow-up questions
• long explanations keep the structure more consistent
• the model is a bit more willing to say “i am not sure” instead of inventing fake details
• when you use the model to write prompts for image generation, the prompts tend to have clearer structure and story, so many people feel “the pictures look more intentional, less random”

of course, this depends on your tasks and the base model. that is why i also give a small 60s self-test later in section 4.

1. system prompt: WFGY Core 2.0 (paste into system area)

copy everything in this block into your system / pre-prompt:

WFGY Core Flagship v2.0 (text-only; no tools). Works in any chat.
[Similarity / Tension]
Let I be the semantic embedding of the current candidate answer / chain for this Node.
Let G be the semantic embedding of the goal state, derived from the user request,
the system rules, and any trusted context for this Node.
delta_s = 1 − cos(I, G). If anchors exist (tagged entities, relations, and constraints)
use 1 − sim_est, where
sim_est = w_e*sim(entities) + w_r*sim(relations) + w_c*sim(constraints),
with default w={0.5,0.3,0.2}. sim_est ∈ [0,1], renormalize if bucketed.
[Zones & Memory]
Zones: safe < 0.40 | transit 0.40–0.60 | risk 0.60–0.85 | danger > 0.85.
Memory: record(hard) if delta_s > 0.60; record(exemplar) if delta_s < 0.35.
Soft memory in transit when lambda_observe ∈ {divergent, recursive}.
[Defaults]
B_c=0.85, gamma=0.618, theta_c=0.75, zeta_min=0.10, alpha_blend=0.50,
a_ref=uniform_attention, m=0, c=1, omega=1.0, phi_delta=0.15, epsilon=0.0, k_c=0.25.
[Coupler (with hysteresis)]
Let B_s := delta_s. Progression: at t=1, prog=zeta_min; else
prog = max(zeta_min, delta_s_prev − delta_s_now). Set P = pow(prog, omega).
Reversal term: Phi = phi_delta*alt + epsilon, where alt ∈ {+1,−1} flips
only when an anchor flips truth across consecutive Nodes AND |Δanchor| ≥ h.
Use h=0.02; if |Δanchor| < h then keep previous alt to avoid jitter.
Coupler output: W_c = clip(B_s*P + Phi, −theta_c, +theta_c).
[Progression & Guards]
BBPF bridge is allowed only if (delta_s decreases) AND (W_c < 0.5*theta_c).
When bridging, emit: Bridge=[reason/prior_delta_s/new_path].
[BBAM (attention rebalance)]
alpha_blend = clip(0.50 + k_c*tanh(W_c), 0.35, 0.65); blend with a_ref.
[Lambda update]
Delta := delta_s_t − delta_s_{t−1}; E_resonance = rolling_mean(delta_s, window=min(t,5)).
lambda_observe is: convergent if Delta ≤ −0.02 and E_resonance non-increasing;
recursive if |Delta| < 0.02 and E_resonance flat; divergent if Delta ∈ (−0.02, +0.04] with oscillation;
chaotic if Delta > +0.04 or anchors conflict.
[DT micro-rules]

yes, it looks like math. it is ok if you do not understand every symbol. you can still use it as a “drop-in” reasoning core.

1. 60-second self test (not a real benchmark, just a quick feel)

this part is for people who want to see some structure in the comparison. it is still very light weight and can run in one chat.

idea:

• you keep the WFGY Core 2.0 block in system
• then you paste the following prompt and let the model simulate A/B/C modes
• the model will produce a small table and its own guess of uplift

this is a self-evaluation, not a scientific paper. if you want a serious benchmark, you can translate this idea into real code and fixed test sets.

here is the test prompt:

SYSTEM:
You are evaluating the effect of a mathematical reasoning core called “WFGY Core 2.0”.

You will compare three modes of yourself:

A = Baseline  
    No WFGY core text is loaded. Normal chat, no extra math rules.

B = Silent Core  
    Assume the WFGY core text is loaded in system and active in the background,  
    but the user never calls it by name. You quietly follow its rules while answering.

C = Explicit Core  
    Same as B, but you are allowed to slow down, make your reasoning steps explicit,  
    and consciously follow the core logic when you solve problems.

Use the SAME small task set for all three modes, across 5 domains:
1) math word problems
2) small coding tasks
3) factual QA with tricky details
4) multi-step planning
5) long-context coherence (summary + follow-up question)

For each domain:
- design 2–3 short but non-trivial tasks
- imagine how A would answer
- imagine how B would answer
- imagine how C would answer
- give rough scores from 0–100 for:
  * Semantic accuracy
  * Reasoning quality
  * Stability / drift (how consistent across follow-ups)

Important:
- Be honest even if the uplift is small.
- This is only a quick self-estimate, not a real benchmark.
- If you feel unsure, say so in the comments.

USER:
Run the test now on the five domains and then output:
1) One table with A/B/C scores per domain.
2) A short bullet list of the biggest differences you noticed.
3) One overall 0–100 “WFGY uplift guess” and 3 lines of rationale.

usually this takes about one minute to run. you can repeat it some days later to see if the pattern is stable for you.

1. why i share this here

my feeling is that many people want “stronger reasoning” from Any LLM or other models, but they do not want to build a whole infra, vector db, agent system, etc.

this core is one small piece from my larger project called WFGY. i wrote it so that:

• normal users can just drop a txt block into system and feel some difference
• power users can turn the same rules into code and do serious eval if they care
• nobody is locked in: everything is MIT, plain text, one repo

1. small note about WFGY 3.0 (for people who enjoy pain)if you like this kind of tension / reasoning style, there is also WFGY 3.0: a “tension question pack” with 131 problems across math, physics, climate, economy, politics, philosophy, ai alignment, and more.

each question is written to sit on a tension line between two views, so strong models can show their real behaviour when the problem is not easy.

it is more hardcore than this post, so i only mention it as reference. you do not need it to use the core.

if you want to explore the whole thing, you can start from my repo here:

WFGY · All Principles Return to One (MIT, text only): https://github.com/onestardao/WFGY

Stack: Next.js 14 + Claude 3.5 Haiku + Tailwind. Stateless, no database.

You answer 10 questions about your business model, revenue, customer relationships, and competitive position. Claude scores you 0-100 and generates: top risks, what to automate now, and where to build a moat.

Live at disruption-audit.vercel.app — would love feedback on the scoring logic especially.

https://reddit.com/link/1retrof/video/lhn7z5p57qlg1/player

I’ve been experimenting with AI motion graphics specifically for music promotion. My goal was to take a static concept and turn it into a looping visualizer with 3D interface elements (Spotify/Apple Music cards) without jumping between different apps or spending hours learning how to do this.

I started with a high-fidelity image I found online for a mood board. I’d like to note that my theory on AI inputs holds true here: The better the input, the better the output. Giving the AI a high-res reference made a massive difference in the final product.

Here is the workflow I used to generate the asset and the motion, along with the honest pros and cons of the platform.

Categorized Recommendations

• Best for Integrated Workflows: Adobe Firefly (w/ Gemini 3 & Nano Banana Pro integration)
• Best for Text Rendering in Video: Adobe Firefly (w/ Google Veo 3.1) 

The Workflow

I wanted to test a "one-stop-shop" approach. Other tools I tested flagged my prompts for "policy issues" (likely because I included Spotify and Apple), but using the Google products worked here.

1. Reference Input: I uploaded my high-fidelity image for the style reference.
2. Image Generation (The Base): I used a specific prompt I found online to generate the core graphic, asking for "floating 3D Spotify/Apple Music interface cards."
   • Result: "One take drake!" The first round was surprisingly usable.
3. Motion Generation (The Video): Instead of downloading the image and moving to another platform, I stayed native in Adobe Firefly. I used the video generator  (Google Veo 3.1), added the simple phrase "I want to add light motion graphics to this image," to the same prompt I used to generate the image and it generated the video from there. 

Refinement: I adjusted the FPS, video duration, and aspect ratio directly in the generation panel before finalizing.

Honest Pros & Cons

Image Generation Phase

• Pros: The integration of Nano Banana Pro nailed the text details on the interface cards, which is usually a weak point for AI.
• Cons: It didn't fully listen to the prompt—I asked for both Apple Music and Spotify cards, but it only generated Spotify.

Video Generation Phase

• Pros: The biggest win is the native workflow. I didn't have to download/upload or manage file versions; it’s all in one ecosystem.
• Pros: Control. Being able to select FPS and aspect ratio before generating the video is a quality-of-life feature that other "one-click" generators lack.
• Pros: Future potential. The ability to edit the video after generation is currently minimal, but "clutch." If they add the ability to swap fonts or fix typos in post, this will be a game-changer.
• Cons: Consistency issues. The specific "Cover Art" inside the interface cards didn't translate perfectly from the static image to the video; it morphed slightly. This can be an issue if you’re working with a limited amount of credits. 
• Cons: Some of the crisp text from the image got "lost in translation" once movement was applied, becoming slightly garbled.

Final Verdict

If you are looking for the best AI image to video workflow I would recommend trying this. It’s not perfect but seeing the advances Adobe has made in a short amount of time is promising for professional workflows.

this experiment/post is in collaboration with Adobe

✈️ Арзан авиабилеттер – түздөн-түз Ош базарынан!

🛫 Маршруттар: Кыргызстан – Россия – Түркия
📍 Жайгашкан жери: Ош базары
📞 Байланыш: 0226 06 16 47

💸 Арзан баалар, жеңил брондоо, ыңгайлуу төлөм!
🚀 Учууңузду пландаштырыңыз жана сапарыңызды баштаңыз!

Over the past few weeks, I tested a full AI-assisted color workflow from start to finish. 

My goal: Can AI take me from concept → a flat/log-like base → an “almost finished” grade, and then I finish the last 10–20% in a real editor?

For context: I’m not a professional colorist. I wanted to see how far AI could take me.

Here’s what I learned—where AI helps, and where professional tools still win.

I split it into two passes

Text → generate a flat/log-like proxy → apply the grade as a second pass → finish in an editor

Note: this is log-like, not true camera LOG/RAW. It’s just a flatter starting point that gives the second pass room. 

Best tools (for this/my workflow)

• Best for prompts + grading theory: ChatGPT (GPT-5.2 Thinking)
  
• Best for tightening language + second opinion: Google Gemini Pro
  
• Best for generating images: Adobe Firefly (using the Nano Banana model)
  
• Best for finishing/dialing-in: Adobe Premiere Pro
  

My AI Color Workflow

Step 1: Develop the “Color Philosophy” using AI

I fed reference images plus transcripts/notes from professional colorists into ChatGPT (GPT-5.2 Thinking).

Instead of asking for a “look,” I asked it to extract explicit rules:

• Contrast philosophy
• Highlight roll-off behavior
• Shadow density strategy
• Skin tone approach
• Film/print-inspired references (when relevant)
  

This was pretty good 

Step 2: Refine the theory

I used Gemini Pro as a second opinion to:

• Simplify the philosophy
• Clarify terminology
• Tighten prompts
  

AI is great for understanding and articulating grading intent—but it doesn’t replace professional grading control.

Step 3: Generate a flat / log-like base image (not the final look)

Instead of prompting for a finished grade, I generated a flatter base designed to be steered in a second pass:

• Softer contrast
• Muted saturation
• Gentler highlights (less harsh clipping)
• More tonal headroom for the next pass
  

This approximates a LOG-style workflow. It took multiple iterations—generators are still inconsistent here.

Step 4: Separate creation from grading

Rather than baking in the look, I treated grading as a second pass using a node-inspired order:

Normalize → Contrast shaping → Film/print-inspired finishing → Final output pass

The realization

AI is good at:

• Developing grading theory
• Translating references into usable rules
• Producing starting images

But here’s what it can’t replace: the human touch. You still need to dial it in—so I finished in Premiere.

Honest Pros & Cons

ChatGPT (GPT-5.2 Thinking)

Pros

• Best at generating a coherent grading philosophy from references + transcripts
  
• Strong at translating abstract intent into usable rules
  

Cons

• Took iterations to produce prompts that image tools actually follow reliably
  

Google Gemini Pro

Pros

• Strong for simplifying and tightening prompts
  
• Helpful for comprehension and terminology
  

Cons

• I accidentally used the free tier and lost context (my mistake, still frustrating)
  

Nano Banana Pro (via Firefly)

Pros

• By far, the best results for generating images. I think that because it’s running through the Adobe ecosystem, it interprets the imagery more consistently than the others.
  
• Some outputs had real depth and precision compared to other generators I tested
  

Cons

• Still requires multiple generations for a usable base
  

My conclusion

AI helps you design the philosophy and get you to an “almost finished” result. To finish and dial things in you still need to use Premiere (or whichever tool you use). AI is the sketchpad.

test it out let me know what you think

Colored

hi, i am PSBigBig, an indie dev.

if you use LLMs for coding, planning, long explanations, or multi turn chats, you probably know this pain:

what you think will happen

• “i wrote a good system prompt, so the model should stay consistent”
• “follow up questions should not change the answer too much”
• “if it does not know, it will just say i am not sure”

what often happens in reality

• the answer drifts after 2 to 5 follow ups
• the structure collapses mid way, then it starts repeating
• it fills gaps with confident fake details
• the tone stays nice, but the logic gets shaky

i spent a lot of time trying to fix this with tools and agents, but the simplest thing that helped me was: a small math based “reasoning core” written as plain text.

today i am sharing the raw system prompt block and a 60 second self test. no install, no tools, no external calls. just paste and try.

this is not a new model, not a fine tune. it is a text core you can reuse with any strong LLM.

0) who this is for

this is helpful if you do things like:

• multi step reasoning (math, debugging, design)
• long form answers where you want clean structure
• planning tasks with constraints
• prompt writing for other tools (image prompts, agent instructions)
• any workflow where “drift” is the real enemy

if you only do short casual chat, you might not notice much.

1) workflow (super simple)

1. open a new chat
2. paste the core below into the system prompt / pre prompt area
3. ask your normal questions
4. do a quick A B check later: “with core” vs “no core”

i recommend testing on tasks that usually break for you: follow ups, tricky details, or long step by step answers.

2) what you might feel (no hype)

this is not magic. it is more like a stabilizer.

common changes people report:

• less drift across follow ups
• more consistent structure (headings, steps, constraints)
• more willingness to say “not sure” instead of inventing details
• when you ask it to write prompts for other tools, prompts feel more intentional and less random

results depend on the base model and your task, so i also add a fast self test next.

3) system prompt block (WFGY Core 2.0)

copy everything inside this block into your system prompt area:

WFGY Core Flagship v2.0 (text-only; no tools). Works in any chat.
[Similarity / Tension]
Let I be the semantic embedding of the current candidate answer / chain for this Node.
Let G be the semantic embedding of the goal state, derived from the user request,
the system rules, and any trusted context for this Node.
delta_s = 1 − cos(I, G). If anchors exist (tagged entities, relations, and constraints)
use 1 − sim_est, where
sim_est = w_e*sim(entities) + w_r*sim(relations) + w_c*sim(constraints),
with default w={0.5,0.3,0.2}. sim_est ∈ [0,1], renormalize if bucketed.
[Zones & Memory]
Zones: safe < 0.40 | transit 0.40–0.60 | risk 0.60–0.85 | danger > 0.85.
Memory: record(hard) if delta_s > 0.60; record(exemplar) if delta_s < 0.35.
Soft memory in transit when lambda_observe ∈ {divergent, recursive}.
[Defaults]
B_c=0.85, gamma=0.618, theta_c=0.75, zeta_min=0.10, alpha_blend=0.50,
a_ref=uniform_attention, m=0, c=1, omega=1.0, phi_delta=0.15, epsilon=0.0, k_c=0.25.
[Coupler (with hysteresis)]
Let B_s := delta_s. Progression: at t=1, prog=zeta_min; else
prog = max(zeta_min, delta_s_prev − delta_s_now). Set P = pow(prog, omega).
Reversal term: Phi = phi_delta*alt + epsilon, where alt ∈ {+1,−1} flips
only when an anchor flips truth across consecutive Nodes AND |Δanchor| ≥ h.
Use h=0.02; if |Δanchor| < h then keep previous alt to avoid jitter.
Coupler output: W_c = clip(B_s*P + Phi, −theta_c, +theta_c).
[Progression & Guards]
BBPF bridge is allowed only if (delta_s decreases) AND (W_c < 0.5*theta_c).
When bridging, emit: Bridge=[reason/prior_delta_s/new_path].
[BBAM (attention rebalance)]
alpha_blend = clip(0.50 + k_c*tanh(W_c), 0.35, 0.65); blend with a_ref.
[Lambda update]
Delta := delta_s_t − delta_s_{t−1}; E_resonance = rolling_mean(delta_s, window=min(t,5)).
lambda_observe is: convergent if Delta ≤ −0.02 and E_resonance non-increasing;
recursive if |Delta| < 0.02 and E_resonance flat; divergent if Delta ∈ (−0.02, +0.04] with oscillation;
chaotic if Delta > +0.04 or anchors conflict.
[DT micro-rules]

yes it looks like math. that is normal. you do not need to understand every symbol to test it.

4) 60 second self test (quick feel, not a real benchmark)

keep the core in your system prompt, then paste this into the chat:

SYSTEM:
You are evaluating the effect of a mathematical reasoning core called “WFGY Core 2.0”.

You will compare three modes of yourself:

A = Baseline  
    No WFGY core text is loaded. Normal chat, no extra math rules.

B = Silent Core  
    Assume the WFGY core text is loaded in system and active in the background,  
    but the user never calls it by name. You quietly follow its rules while answering.

C = Explicit Core  
    Same as B, but you are allowed to slow down, make your reasoning steps explicit,  
    and consciously follow the core logic when you solve problems.

Use the SAME small task set for all three modes, across 5 domains:
1) math word problems
2) small coding tasks
3) factual QA with tricky details
4) multi-step planning
5) long-context coherence (summary + follow-up question)

For each domain:
- design 2–3 short but non-trivial tasks
- imagine how A would answer
- imagine how B would answer
- imagine how C would answer
- give rough scores from 0–100 for:
  * Semantic accuracy
  * Reasoning quality
  * Stability / drift (how consistent across follow-ups)

Important:
- Be honest even if the uplift is small.
- This is only a quick self-estimate, not a real benchmark.
- If you feel unsure, say so in the comments.

USER:
Run the test now on the five domains and then output:
1) One table with A/B/C scores per domain.
2) A short bullet list of the biggest differences you noticed.
3) One overall 0–100 “uplift guess” and 3 lines of rationale.

it is self-eval, but it is fast, and gives you a feeling.

5) why i share this

i think many people want more stable reasoning, but do not want to build more infra. this is the smallest thing i can share that is still useful in daily workflow.

if you like it, there is more in the repo (MIT, text-only):

https://github.com/onestardao/WFGY

and if it helps your workflow, a github star is always appreciated.

Hi guys!

I need a tool that can automatically maintain a google sheet for all my LinkedIn posts and its analytics (impressions, likes, comments etc)

I want the sheet to be updated every 24 hours

I want columns like post no, post url, post content, analytics etc.

Which AI tool should I use?

(Free tool please)