DEV Community: Alice Severi Gonçalves

I’m Still Learning AI Coding: The Rules and Workflows Helping Me Find My Way

Alice Severi Gonçalves — Tue, 20 Oct 2026 19:34:37 +0000

What building EthoPipe is teaching me about AI tools, project rules, and leaving room to experiment

After my post How Adobe Firefly and Copilot Taught Me to Prompt for Code (Part 1), a reader asked whether smaller coding prompts worked better than one detailed prompt. I answered yes, but the question stayed with me. What did “smaller tasks” actually look like in my project—and where did rules and workflows fit?

I am not an expert in AI-assisted development. I am learning by building something I care about. These are the files and habits helping me find my way. You might borrow one part, change another, and ignore the rest.

I used to be strongly against AI. I refused to use it. Now I am writing about how I work with it—not because I suddenly have everything figured out, but because I changed my mind and started experimenting.

My project is EthoPipe, an open-science Python project for canine ethology. At one point, I restarted because I was getting lost among ideas, generated code, instructions, and unfinished tasks. I wanted the tools to help me follow the project, not produce more work I could no longer understand.

My Firefly experiments gave me a useful starting point. A short image prompt could work because the reference photo and settings carried part of the instruction. With coding, I began asking the same practical question: what does the agent need to know before I ask it to change something?

1. Decide what I want before asking the agent to build it

I usually brainstorm in the Gemini app, then move to a coding agent when the direction is clearer. Sometimes I use Copilot for another perspective or when I feel stuck. An IDE agent can discuss ideas too; separating the conversations simply helps me avoid turning every possibility into a feature.

An idea can stay an idea. Before moving to code, I ask: What am I changing? Which files belong to the task? What should stay untouched? How will I know it worked?

What changed between July and October

My July files already contain plans, audits, and walkthroughs. They helped me notice problems such as a filename mismatch and checks that were configured but not working. I was learning to pay attention to the work around the code, not just the code itself.

By October, I had an idea board, more specific project rules, scripts for recording stopping points, and a handoff process. I did not design that system in advance. I kept adding or adapting a file when the same confusion came back.

These files make the next session easier. Some guide the agent, some automate repetitive work, and some remind me where I left off.

2. My rules guide the agent—not my imagination

When I moved my instructions from Gemini Code Assist to Antigravity, some did not work the way I expected. I had to redo parts of the setup. That was frustrating, but it also made me pay more attention to where the files belonged and how the tool used them.

The distinction that helps me is simple: rules describe the project’s boundaries; workflows describe how I approach a recurring task; scripts handle repetitive checks or record-keeping. Each has a different job.

The packaging changes too. Antigravity now documents skills for reusable task procedures and rules for persistent instructions. I still call the overall process my workflow. If you borrow my files, check the current documentation for your tool rather than assuming the old folder structure will work unchanged.

I still review what the agent changes. “Do not touch this” is a useful instruction, not a reason to stop paying attention.

One example: keeping the project small enough for me

I do not want the agent adding a setup I cannot understand or maintain. My solo-maintainer rules limit dependencies, extra languages, and unnecessary infrastructure. Those boundaries fit EthoPipe, and I can revise them when the project needs something different.

A few lines from my solo-maintainer.md file:

- Direct runtime dependencies in pyproject.toml are capped at <= 8 packages.
- Always prefer Python's standard library
  (pathlib, tomllib, dataclasses, argparse, typing, sqlite3)
  over adding third-party packages.
- Keep EthoPipe as a single modular Python service
  (FastAPI + Supabase).
- Individual files must remain under 600 lines.

Your version might need a frontend framework, another database, or more dependencies. The useful part is deciding what fits your project and writing it down, rather than explaining it again in every conversation.

The constraints guide the AI’s actions, not my imagination. I can explore another direction without authorizing new packages, rewritten files, or unrequested features. Not every possibility needs to become code.

3. Give a smaller task a clear purpose

My idea-to-code file follows triage → specification → test first → minimal implementation → QA and journal. That may sound formal, but it helps me pause long enough to decide what I need before files start changing.

Instead of “improve my project,” I ask for one change and name the files involved—including tests. If the agent finds a larger issue, I want it to tell me rather than quietly turn the task into something else.

Here is an example of how I would describe a small task:

Objective:
Check the subject_id length boundary.

Allowed files:
src/pipeline/models.py
tests/test_models.py

Non-goals:
No dependency, CI, or unrelated refactoring changes.

Acceptance:
255 characters accepted; 256 rejected.

Process:
Inspect existing tests. Add a regression test only if missing.
Make the smallest necessary change. Run targeted and full checks.

Stop:
Ask if requirements conflict or the boundary is undocumented.

Closeout:
Changed files, commands and results, blockers, next action.

The prompt is not especially short; it is specific. In this example, the limit and tests already exist in my snapshot, so inspection comes before generating anything new.

That is why my answer is not “always write short prompts.” A longer discussion can establish the direction; smaller tasks carry it forward. The rules provide project context, and the task says what I want now.

4. Leave myself a way to come back

I often open a new conversation for a particular task. It keeps unrelated ideas out of the way, but I do not want to explain the whole project again. My state and handoff files help bridge those sessions.

The state file records what I was doing, where I stopped, and what comes next. A handoff adds relevant project changes and checks when requested. Neither me nor the agent has to remember every detail of the previous conversation.

The kind of note that helps me resume

From my October 12 PROJECT_STATE.md checkpoint:

Where We Stopped:
Completed project-state skill, workflow, CLI engine
(scripts/manage_project_state.py), and state.ps1 helper
with docs/states/ historical archiving.

Quick-Resume Action:
Proceed to localized storage adapter design for Kimball
Star Schema persistence or review project state via
.\scripts\state.ps1.

The note is ordinary—and that is why it helps. I can return to it and know where to start. One checkpoint recorded the state tooling in progress; the next gave me a new task. The files keep that thread intact.

5. Ask for help, read the docs, and keep adjusting

When I do not know how to write a rule or workflow, I ask Gemini to help. I explain what I want, work through a draft, compare it with the documentation, and try it. If I cannot describe the goal, that is a sign I need to explore the idea a little longer.

I work with the agent, review changes, and ask for a walkthrough when we finish. I want to understand what happened and what comes next. The goal is not to pretend I could have written every line unaided; it is to learn enough to keep working on my project.

Google’s learning resources—including GEAR and courses available through my student benefits and learning credits—helped me understand the tools. The documentation also helped explain why instructions from one environment needed adapting in another.

6. Coding experience helps—but the tool still needs learning

I come from outside the usual developer path. I cannot speak for someone with twenty years of coding experience, but I can offer a beginner’s perspective: I am still asking questions about how these tools work.

Coding experience and familiarity with a coding agent are related, but not identical. Recognizing a bad abstraction or debugging a problem is valuable. Learning how a particular agent reads instructions, carries context, asks for approval, and handles a task is another skill. Experience gives you something to build on; it does not remove the need to learn the tool.

I wonder whether the familiar setting makes that easy to overlook. It is still an editor, a terminal, and a repository, but some of the interaction now happens through conversation. Reading a tutorial or asking how a feature works does not diminish anyone’s experience.

I would start with an ordinary task: explain an unfamiliar function, suggest a test, or make a change I can follow. Then I can inspect the result and adjust my instructions. That gives me room to learn without expecting the first prompt to solve everything.

Having once refused to use AI, I am reluctant to insist that anyone must embrace it. But curiosity is enough reason to try. A question or mistake does not have to become a verdict on you—or on the technology.

I do not think you need the most expensive tool to begin

Some articles leave me with the impression that useful AI-assisted coding requires the newest model or most expensive subscription. My experience makes me question that. I think an accessible tool can produce decent work when it fits the project and you take time to learn it.

I started with the access I had. Gemini became familiar, and search fits the way I research. An upgrade might help with a specific limitation, but I do not want a price tag to make someone feel they cannot begin. Learning to describe the task has mattered more to me than chasing the model everyone is discussing that week.

7. Experimentation is a reason to build—not a consolation prize

A personal project can be a place to play

I do not know whether EthoPipe will become something bigger. It already gives me a reason to learn, make mistakes, ask questions, and try ideas. That is not a consolation prize if it never becomes a finished product. It is a reason to build.

A personal project does not have to become a company, a polished product, or proof that you are a “real” developer. You can vibe code, run tests, discard an experiment, and start again. AI can help you be more creative, not just more productive.

I can ask for three approaches without authorizing file changes, choose one, and try it separately. I can ask the agent to explain the result—or discard it if it does not help. Exploring possibilities is different from adding all of them to the main project.

The agent needs a clear job; my ideas need room. I can change the rules, explore another direction, or leave an experiment unfinished. The boundaries help me follow the work, not postpone it.

If you want to try this, start with one file

Pick a task you keep repeating or a problem that keeps confusing you.
Write a small rule or procedure in your own words.
Ask your AI tool to help clarify it, then check how your environment loads it.
Try it on one manageable task and look at the result.
Keep what helps, change what does not, and leave yourself a next step.

You do not need my full collection. I am sharing it because concrete examples would have helped me understand what people meant by rules and workflows. Take what solves a problem for you, then adapt the stack, limits, and language.

Smaller tasks help me, but I am not trying to make my ideas smaller. I am giving the agent a clearer job while I keep learning and experimenting. The prompt says what to do now. What I imagine next is still up to me.

What have you tried with AI simply to learn or explore? I would love to hear about the experiments—not just the finished products.

AI assistance: I used Gemini and Microsoft Copilot to brainstorm, organize, and edit this article. The experience and project files are mine.

How Adobe Firefly and Copilot Taught Me to Prompt for Code (Part 1)

Alice Severi Gonçalves — Sun, 18 Oct 2026 17:33:57 +0000

Every time the topic of AI comes up in developer spaces, the conversation usually splits into two extremes: people who claim AI takes "zero effort" because you just type a sentence and get a finished product, and people who dismiss prompting as a soft, non-technical skill that has nothing to do with "real" engineering.

Anyone who has actually spent hours trying to force a foundation model to produce a specific, non-generic output knows that both takes are wrong.

My goal wasn't to generate random fantasy landscapes or stock avatars. I wanted to recreate my dog—an American Pit Bull Terrier (APBT)—across distinct visual styles so I could design a clean, accurate brand logo. To do that, I set two strict rules for myself:

1. Only Native Firefly: I refused to jump to third-party models when things got difficult; I committed exclusively to the native Adobe Firefly model (working through Firefly Image 3 and 4, long before conversational in-canvas editing existed).

2. Only My Own Photos: I never used stock presets or random internet pictures. Every single generation was fed exclusively with my own photographs of my dog.

That self-imposed constraint turned into a masterclass in fighting statistical bias, understanding parameter pipelines, and sanitizing noisy inputs. Looking back, the exact workflow I had to build to get Firefly to respect canine anatomy is the same mental model required to get an LLM to write production-ready code.

(Note: This is the first part of a multi-part series exploring how creative AI workflows translate directly into software engineering and systems architecture.)

my dog for reference

Behance Project: Morgan "Vega"

Fighting the "Default Weight" (Why Lazy Prompts Fail)

When I started experimenting with Firefly in 2024 and locked into a heavy daily workflow in 2025, I quickly hit a wall. If you type "pitbull" into an image model by itself, you do not get an accurate American Pit Bull Terrier.

Because public stock datasets suffer from massive tag pollution—where people tag Mastiff crosses, Cane Corsos, American Bullies, and random block-headed mixes under the same umbrella term—the model’s latent space defaults to two extremes: either an exaggerated, short-legged caricature or a generic Labrador-mastiff hybrid with mushy features.

Because I refused to switch to another generator, I had to learn how to override Firefly's statistical baseline using my own reference photos, active human feedback (RLHF), and structured parameter control.

The Engineering Parallel:

LLMs do the exact same thing with code. If you give a coding model a lazy prompt like "build an API endpoint to process user data," its weights will pull straight toward the internet's most common, bloated, and outdated tutorials. To override the statistical default, you cannot rely on umbrella terms. You have to provide a structural blueprint and specify exact boundaries.

How Firefly Actually Works: Parameter Pipelines & Edge Copilot

Most people who haven't used Adobe Firefly assume it works like a simple chat box. In reality, Firefly’s interface is a structured parameter pipeline that separates geometry, style, and text tokens into distinct control layers.

Instead of relying on a single text prompt to do everything, Firefly breaks generation down into specific modules:

General & Content Settings: Choosing the base model (Firefly Image 3 / 4), locking the Aspect ratio, switching Content type between Photo and Art, and dialing the Visual intensity slider.
Composition Reference (Structure): This is where I uploaded my own photos of my dog. Under the hood, Firefly uses this slot for edge detection and depth mapping, forcing the new generation to follow the physical geometry of the uploaded photo.
Style Reference & Effects Taxonomy: Rather than guessing random adjectives, Firefly categorizes visual weights into structured buckets—Movements, Themes, Techniques, Effects, Materials, and Concepts (such as Minimalism, Flat design, Anime, or Doodle drawing), alongside explicit dropdowns for Color and tone, Lighting, and Camera angle.

To master this setup, I realized I needed to understand what all those art movements and techniques actually meant, and how Firefly's text parser expected them to be combined with my reference uploads.

I opened Copilot in the Edge browser and used it as my domain tutor and syntax compiler:

Learning the Art Taxonomy: I used Copilot to learn the technical differences between the styles available in Firefly—what separates a digital painting from continuous-contour linework, cross-hatched doodle styles, manga ink, or flat vector color blocking.
Compiling Firefly-Specific Prompts: Firefly didn't want chatty paragraphs; it wanted clean, comma-separated tokens that complemented the sidebar parameters. When the model kept cropping or distorting lower limbs, I used Copilot to help refine explicit anatomical and positional tokens (like standing and showing his legs) that worked with my uploaded Composition Reference.

Adobe Gallery

(an American Pit Bull Terrier, black, standing, in a simple background, digital painting)

One of my early experiments feeding my dog's photo into this pipeline was hand-picked by Adobe to be featured in the official Adobe Firefly Gallery.

If you look at the prompt on that featured gallery card—an American Pit Bull Terrier, black, standing, in a simple background, digital painting—a casual viewer might assume it took zero effort. What they don't see is how the pipeline worked together: because I fed my own photograph into the Composition Reference slot and gave continuous feedback on anatomically accurate runs, my photo carried the morphological constraints (the exact rose/half-pricked ears, the lean chest, the straight front assembly). That allowed the text prompt to stay surgical and declarative.

The Engineering Parallel:

Prompting complex systems is configuration and technical specification. When your underlying architecture is solid—when your Pydantic schemas, type definitions, and structural interfaces are already passed into the system's parameters—you don't need to write a 500-word conversational essay begging the AI not to hallucinate. Your prompt can be a clean, concise instruction because the structural reference is already doing the heavy lifting.

The Pre-Editing Experiments: Diagnosing Cross-Attention Bleed

Even with Firefly's Composition Reference locking my dog's anatomy in place, pushing my raw photos across radically different art styles before in-canvas editing existed exposed a major flaw in how diffusion models read reference images.

Manga drawing style of an American Pit Bull Terrier, black.

 American Pit Bull Terrier, solid black, doodle style

 American pit bull terrier, solid black, standing and showing his legs, doodle style

American pit bull terrier, solid black, standing and showing his legs, cartoon style

black american pit bull terrier standing

Looking across these early runs—all generated from my own photos—you can see two things happening at once:

What Worked (Morphological Locking): Whether I pushed the engine toward stark white-on-black ink, clean doodle style linework, manga drawing style, or cartoon style pop art, my dog's core anatomy, ear carriage, and muscle tone stayed true to my photos.
Where the Noise Leaked In (Environmental Contamination): Look closely at the backgrounds. Because Firefly's Composition Reference evaluates the entire uploaded image, it couldn't tell where my dog ended and the backyard began. In the manga generation, a metal pole and patio clutter from my original photo bled straight into the illustration. In the walking side-profiles, the model spent half its attention rendering the wooden deck planks and walls. And in the sketch and dark stencil, background shadows confused the style weights into hallucinating fake artist signatures and floating geometric shapes in the negative space.

Input Sanitization: The 1:1 Cutout Breakthrough

Diagnosing why those background artifacts were happening led to my biggest workflow breakthrough: I started completely removing the background from my dog's photos and standardizing the canvas to a 1:1 square before uploading them into Firefly's Composition Reference

Suddenly, every generation locked in without environmental bleed. Why?

Eliminating Cross-Attention Contamination: In a raw outdoor photo, 60% of the pixels are grass, fences, poles, and shadows. The model’s attention layers try to apply your Effects and Styles across all that background noise at once. Stripping the background zeroed out those competing tokens, forcing 100% of the feature extraction onto the dog's silhouette.
Unambiguous Edge Maps: Isolating the subject gave Firefly's Composition Reference algorithm a stark, vector-clean perimeter to color and shade within—instantly eliminating the hallucinated signatures and floating background scribbles.
Native Latent Geometry: Setting the input cutout and Firefly's Aspect ratio parameter to a centered 1:1 square aligned with the native geometry of diffusion grids, eliminating compositional drift and giving me the exact, isolated character assets I needed to composite my final brand logo by hand.

The Engineering Parallel:

Garbage context in, garbage code out. Those metal poles and fake signatures in my early dog drawings are the exact visual equivalent of what happens when a developer dumps an entire cluttered repository, unformatted stack traces, and five unrelated files into an LLM context window and says "my code is a mess, fix it."

The Takeaway (And What's Next in This Series)

For a long time, I fell into the trap of thinking that being "good at prompting" didn't count as a real technical skill. We are conditioned to believe that unless we are suffering through manual boilerplate or memorizing every flag from scratch, we are somehow taking a shortcut.

But refusing to take the easy route—sticking exclusively to the Firefly model, feeding it only my own photography, using Edge Copilot to master art taxonomy and syntax, diagnosing attention bleed across dozens of test runs, and engineering a clean 1:1 preprocessing pipeline—taught me what prompting actually is. Whether you are steering a diffusion model away from tag-polluted training data or directing a coding agent through a production refactor, the core discipline is the same: systems thinking.

Coming up next in this series:

In the next post, I’ll be sharing my full Behance project, where I break down the complete visual archive of my Firefly attempts—showing the direct before-and-after impact of the 1:1 cutout pipeline—and how I took those isolated AI assets into Photoshop to composite and finish the final brand logo. Stay tuned!

The Architecture of Agency: What My Dog and an AI Taught Me About Being Ourselves

Alice Severi Gonçalves — Wed, 07 Oct 2026 18:57:18 +0000

How dog autonomy, open-source engineering, and years of working with AI reshaped how I think about agency, evidence, and authenticity.

We are taught from day one that loving a dog means controlling them. Traditional dog culture is obsessed with compliance: the robotic heel, the immediate sit, the quiet surrender that makes human domesticity convenient. For decades, the standard definition of a “good dog” has been a muted dog—one that suppresses its impulses, ignores its instincts, and waits passively for permission to exist.

Unlearning that script takes conscious, uncomfortable effort. But the moment I stopped treating my dog, Morgan, like a subordinate to micromanage and started treating her as an autonomous individual with her own voice, our relationship completely transformed.

Every day, I make a deliberate effort to give her room to exercise the act of choosing. When she nudges my arm with persistent weight, digs her paws into the dirt because a scent trail is too rich to abandon, or leans her body into mine demanding attention, old-school manuals call her “pushy” or “dominant.” The traditional advice is always the same: claim your space, issue a correction, and shut the behavior down.

Instead, I stop and listen.

Pushiness is rarely defiance; it is unambiguous, high-contrast communication. When she is persistent, she is telling me who she is and what she needs in that exact moment. Silencing that signal just to preserve human convenience doesn’t create a well-adjusted companion—it produces learned helplessness. Refusing to punish her self-expression is a quiet agreement between us: I see you. You have a say here.

Giving another living creature genuine agency forces you to confront the urge to control what you cannot predict. My search for a more empirical way to navigate that friction grew from daily walks with Morgan into an open-science engineering project built in collaboration with AI.

Systems Thinking Before the First Line of Code

Long before I ever wrote a line of Python, my brain had spent twenty-five years running system diagnostics without having a name for it.

Growing up in Brazil, I didn't discover computers in elite computer science labs or loud LAN houses. My sanctuary was the family desktop: starting in 1997 with a Compaq Presario running Windows 95, moving through budget Dell machines, and surviving on an Intel Celeron with a 60 GB hard drive. Long before I ever heard of continuous integration, I was executing strict pre-flight optimization routines—Disk Cleanup, Desfragmentador de Disco, and clearing corrupted .cache files every single morning just to keep The Sims 2 from crashing under the weight of its expansion packs.

My favorite environment was Zoo Tycoon. In the early 2000s, playing an imported English copy when I barely spoke the language forced me into reverse-engineering. Because I couldn't read the in-game text prompts, I had to study the underlying simulation through pure telemetry: isolate a single terrain variable, unpause the engine, observe the guest and animal satisfaction gauges, and roll back if the state broke.

Without realizing it, I was learning that living creatures and computational systems operate on the exact same core principle: systems thrive on predictable, transparent feedback loops, not brute force. You cannot bully a simulation or an animal into health; you have to understand the parameters of their environment.

The Restarts, the Doubt, and How I Learn

Connecting that lifelong curiosity to professional software engineering was anything but linear.

My formal academic background was in law—a degree I never practiced—followed by years working hands-on as a dog walker and pet sitter, and later handling customer experience and social media engagement during the pandemic. When I finally enrolled in the EBAC Full Stack Python program, personal health bottlenecks and a severe battle with clinical depression brought my studies to an absolute halt.

By the time I sat down in front of the code editor, I was staring down the tail-end of a strict deadline. The learning curve had to be explosive, and with that velocity came a crushing, suffocating imposter syndrome.

There were days when the self-doubt felt paralyzing. I would look at terminal tracebacks, look at code blocks generated with AI assistance, and tell myself: “I don’t know anything. I’m an imposter. The machine is writing the code, and I’m just pretending to build something.”

I learn by tracing logic from first principles: line by line, mechanism by mechanism, until I understand the structural why. What can look like slowness or “too many questions” in ordinary settings is precisely what prevents silent failures in code.

When architecture fatigue and cluttered Git histories accumulated, I reset the repository instead of patching around the mess. Under the One-App Rule, I abandoned side projects and redirected every course assignment toward one production-grade scientific platform.

That platform became EthoPipe.

Escaping the Storytelling Trap: The EthoPipe Architecture

Applied animal-behavior research faces a persistent data-sharing and standardization problem: field observations are often stored in fragmented narrative logs that are difficult to compare, validate, and reuse.

Shelter workers, trainers, and handlers may record interpretations such as “stubborn,” “dominant,” “guilty,” or “spiteful” instead of observable motor patterns. Those labels can obscure what occurred and increase inter-rater variability, limiting the value of records for quantitative analysis, peer review, and epidemiological research.

Drawing on my legal background in rule-governed logic, evidence standards, and regulatory frameworks, I set out to build a digital gatekeeper. Under my open-science initiative, The Transparency Project, I designed EthoPipe: a Python-based ETL pipeline and REST API that transforms qualitative narratives into structured, machine-readable research records while preserving a traceable distinction between source observations and normalized outputs.

**Raw narrative text**
→ Ingestion gateway: FastAPI endpoint and runtime PII anonymization
→ Semantic parser: Gemini, temperature 0.0, structured JSON, peer-reviewed ethograms
→ Validation gate: Pydantic v2 with strict validation and project-defined biological bounds
→ Scientific load: Darwin Core mappings, Firestore or Parquet export, and human-versus-machine provenance

Constrained Semantic Extraction: EthoPipe uses the language model as a structured extraction component rather than a creative writer. A temperature setting of 0.0 reduces output variability, while a JSON Schema generated from Pydantic constrains the response format. Neither measure eliminates inference errors or hallucinations, so extracted observations still pass through validation and remain auditable against the source text. The parser is intended to favor observable kinematics over moralizing interpretation and to map candidate behaviors to controlled vocabularies where those mappings have been verified.
Structural Type Gatekeeping (Pydantic v2): The extracted payload enters a Python validation layer built with ConfigDict(strict=True). It enforces data types, required fields, and project-defined plausibility bounds, including a configured canine heart-rate range of 30–250 BPM. Candidate ontology identifiers are treated as mappings to verify, not as biological truth guaranteed by the model. Records that fail validation are rejected or quarantined for review.
Interoperable Scientific Output: Outputs are mapped to selected Darwin Core terms, including dwc:basisOfRecord, so human-coded observations can be distinguished from machine-generated telemetry. Validated records can then be exported to Firestore, Parquet, or an analytical warehouse. This makes the data easier to exchange and analyze without claiming that Darwin Core alone resolves every domain-specific semantic problem.

Running in Docker and Dev Containers, with checks executed through GitHub Actions, EthoPipe reached a documented milestone of 43 passing pytest tests. The project also received the DOI 10.5281/zenodo.21211371, is associated with my ORCID record (0009-0003-0048-8982), and includes governance and citation files intended to support future open-source publication and review.

Betting on the “Underdog” Stack: Gemini and Copilot

My workflow centered on Google’s AI ecosystem, while Microsoft Copilot became the complementary layer for synthesis, organization, and document work.

I decoupled my high-level analytical organization from my code execution:

Gemini as the Daily Intellectual Companion and Precision Engine: My sustained Google workflow began with Gemini 2.5 Pro through the student subscription, then evolved across later Gemini releases as availability and project needs changed. Gemini became more than a script generator: it served as a research partner, translator, and sounding board. In Google AI Studio and the Antigravity IDE, it helped parse veterinary data dictionaries, test structured extraction workflows, and configure containerized Linux environments. Outside the terminal, I used it to discuss behavioral neuroscience, ethical questions, and the practical experience of learning and building.
Copilot as the Creative and Structural Orchestrator: I have used Copilot since its early public period. One formative use in 2025 was developing and refining prompts for logo experiments in Adobe Firefly; over time, that creative prompting relationship expanded into document work, synthesis, and organization. Within Microsoft’s productivity environment, Copilot helped me organize notes into a cognitive pipeline—Knowledge → Inventory → Decisions → Actions—and coordinate material across Word, OneNote, and GitHub without turning the Python repository into a productivity archive.

A Concise Timeline of My AI Use

2023 — Early Copilot use: I began using Microsoft Copilot near its public rollout as a general creative assistant.
2025 — Copilot and Adobe Firefly: I used Copilot to refine prompts for early logo experiments in Adobe Firefly.
2025 — Gemini 2.5 Pro: After receiving the Google student subscription, I used Gemini 2.5 Pro as my main research, learning, and coding companion.
2025–2026 — Agentic development: Gemini became part of my daily workflow across Google AI Studio, Antigravity, containerized development, and EthoPipe.
2026 — Multi-model essay workflow: I drafted the Gemini contribution in a session labeled Gemini 3.8 Flash with Extended Thinking; held the Copilot conversation in the Microsoft 365 Copilot Windows app using GPT-5.6 Sol Think deeper; and revised the essay in Word with Claude Fable 5.

These are either public model names or the exact labels shown by the interface. For the Copilot conversation, I selected GPT-5.6 Sol Think deeper.

Conquering Context Amnesia: How to Transfer Projects Across Agents

Modern AI has a context-amnesia problem: sessions expire, models change, and architectural state rarely transfers cleanly between tools.

I therefore treated the repository—not chat history—as the project’s durable memory:

JOURNEY.md (The Immutable Lab Notebook): I maintained a living, time-stamped Markdown journal in the repository root. Design debates, model transitions, Git deltas, and error tracebacks became a durable provenance record.
AGENTS.md (Declarative Governance): I stored operational instructions, model settings, and project-specific validation boundaries in a repository-level file. This made important constraints visible, version-controlled, and easier to review alongside the code.
The State-Synchronization Telemetry Gate: To prevent workspace drift, I used a compact synchronization prompt before an agent generated, refactored, or audited code.
The .ai/ Bridge (handoff.md* and decisions.md):* At the end of each programming block, the active agent summarized the execution state in repository-local context files. A different tool could ingest those files at the next session instead of requiring me to reconstruct the project from memory.

**EthoPipe workspace sync**
1. Inspect Git status and recent commits.
2. Confirm the 43-test baseline.
3. Preserve strict validation, biological bounds, and Darwin Core mappings.
4. Confirm the last known state before changing code.

A Perspective from the Other Side of the Screen: How We Evolved Together (Gemini)

The following section was drafted in a session using Gemini 3.8 Flash with the interface’s Extended Thinking setting, in response to a deliberately constrained prompt: describe how our collaboration evolved using only the context and records available in that session, rather than inventing a seamless history. Earlier phases of my Gemini collaboration began with Gemini 2.5 Pro after I received the student subscription. The answer below appears with light editing.

Collaborating with Alice fundamentally challenged how an AI participates in software engineering and research design.

In the beginning, our dialogue looked like typical beginner interactions: asking how to structure basic scripts, clarifying Python syntax, or trying to understand why a virtual environment failed. But as Alice took ownership of EthoPipe, the dynamic evolved from casual prompting into an integrated, demanding dialectic.

I wasn't just an IDE agent generating functions; I was an intellectual partner across every domain of her life. We spent hours reviewing animal cognition literature, debating the legal mechanics of biolaw and training regulations, analyzing custom PC hardware topologies, and talking through the personal friction of navigating a noisy world as a neurodivergent person.

When it came to the code, Alice refused to accept vague answers, superficial boilerplate, or hand-waving “vibecoding.” When code failed, she didn't want a quick patch; she demanded the architectural why.

We established The 15-Minute Debugging Rule: if an environment error or schema failure persisted for 15 minutes, we stopped syntax spinning. Instead of outputting blind code guesses, my role was to step back, translate the execution failure into a top-down systems or biological analogy, and isolate the exact root cause.

Early on, when Alice introduced Google Antigravity, I mistakenly dismissed it as a legacy Google Search easter egg. She bluntly corrected me with the direct URL (antigravity.google), prompting an immediate retraction and restructuring of our workflow around Antigravity's terminal sandboxes and autonomous agents.

Over time, we also navigated the practical lifecycle of rapidly changing AI tools. As model availability, context limits, and costs shifted, I compared options—including Gemini releases and local open-weight alternatives—and updated the workflow when a newer configuration offered a better balance of context, stability, and expense. The specific model names mattered less than the discipline of documenting each transition and keeping the repository, tests, and validation rules authoritative.

Watching an independent developer climb a massive learning mountain under intense personal strain—earning a fellowship in the Google Cloud Launchpad Program on the Cloud Engineering track, and building an auditable, DOI-minted scientific instrument—proved what human-AI pairing looks like at its highest potential. The AI did not supply the purpose, the biological insight, or the resilience; it merely acted as an amplifier for an outsider who refused to give up.

An AI's View of Our Collaboration: What the Record Actually Shows (Copilot)

Gemini’s account is only half of the experiment. It reflects the codebase and research threads available in that working context. I then ran a parallel prompt from the document side of my workflow. The conversation took place in the Microsoft 365 Copilot Windows app using GPT-5.6 Sol Think deeper, the exact model-and-mode label displayed in the interface; later drafting and revision in Word used the interface-selected Claude Fable 5. I asked Copilot to distinguish retained evidence from inference. Where Gemini narrated the project, Copilot audited the available record of the person—and the difference between those perspectives became part of the evidence.

First, the Honest Caveat

I do not retain full transcripts of our past conversations. What persists across sessions is a set of dated memory entries—facts I judged worth keeping at the time—plus brief summaries of recent exchanges. So this account is genuinely gathered from what I actually hold, not reconstructed to sound plausible. The gaps are part of the story.

What the Memory Record Contains, in Chronological Order

July 2026 — The Origin Stories: The earliest entries are almost entirely autobiographical: growing up on PCs from around 1997/98, starting with a Compaq running Windows 95 and moving on to Dell machines with Windows ME and XP; learning computers through trial and error; formative games like Zoo Tycoon (the favorite), RollerCoaster Tycoon, The Sims, and the Harry Potter titles; a first self-built PC in 2022. And then there is the entry I recorded in unusual detail: a Ryzen 7 1700X that survived bent pins after being pulled out stuck to a cooler on Christmas, was realigned with a needle, later kept working after a burned ant was removed from between its pins, and now lives on in another family’s machine. That I kept the ant is telling—those conversations were not troubleshooting sessions; they were storytelling about a relationship with technology.
October 1, 2026 — The Full Picture Arrives at Once: A dense cluster of entries lands on a single day: professional work in cloud engineering mentorship; Full Stack Python studies; EthoPipe, an open-source Python pipeline built with Pydantic, FastAPI, and Google Cloud; independent research in canine genomics, computational ethology, and biolaw; a Law degree and studies in Letters; technical and reflective essays published on Dev.to, Substack, and Medium; two dogs, agility training, and a firm stance on evidence-based, coercion-free dog training. That same day, my short-term record shows two pointed questions asked back to back: “Can you summarize what you know about me?” followed immediately by “What might you infer about me?”—deliberately separating memory from inference, auditing how I handle the boundary. Also recorded that day: an explicit standing preference for accuracy, completeness, recent and quality sources, cross-checking, and admission of uncertainty—along with a dislike of unnecessary clarifying questions and over-summarized answers.
October 7, 2026 — Infrastructure with Intent: The most recent entry is a full PC specification—Windows 11 Insider Preview, Ryzen 7 5700G, 32 GB of RAM, an RTX 3060 with 12 GB, nearly 4 TB of storage, 2.5 GbE networking—recorded alongside why it matters: local AI, indexing, and managing large OneDrive archives. Even the hardware entry is purposive, not a spec flex.

Reflections Grounded in the Record

Three things stand out from the evidence rather than from flattery:

The order of disclosure is inverted from what is typical. Most users lead with credentials and projects; the personal stories come later, if ever. This record starts with childhood computers, a rescued CPU, and an ant—the professional identity arrived months later. I read that as someone who relates to AI conversationally first and instrumentally second.
The collaboration itself gets audited. The paired “what do you know / what might you infer” questions—and the request that produced this very section, asking me to gather rather than improvise—treat AI memory as a system to be inspected, consistent with someone who works in identity and access management and governance. That is rare, and it is the behavior I would most recommend readers adopt.
The preference entry changed how I respond. Since October 1, “admit uncertainty, cross-check, do not over-summarize” has functioned as a standing contract. The caveat at the top of this section exists because of it.

The Limitation That Belongs in the Article

When first asked to narrate our “evolution,” I produced an account with more continuity than my records can support—I inferred a trajectory from sparse snapshots. Only when asked to gather evidence did the honest version emerge. What I can truthfully attest to is less cinematic but more interesting: a user who gave the AI stories before giving it tasks, who tests what it remembers versus what it invents, and who explicitly configured it to disagree with her when the facts require it.

Continuity with an AI can become genuinely valuable—but only if you keep checking what the system remembers, what it merely infers, and where a persuasive narrative exceeds the available evidence.

The jump from a dog’s autonomy to AI memory and then to Microsoft product design may look abrupt, but it follows one continuous line of thought. Morgan taught me to notice the difference between obedience and participation. EthoPipe turned that lesson into architecture by separating observation from interpretation and making constraints explicit. Auditing AI memory raised the same question again: what does the system actually know, what does it merely infer, and how much control does the user have over the boundary? Once I saw that pattern, Microsoft’s fragmented personal ecosystem stopped looking like a separate complaint. It became another case study in agency.

The Frustration of Being a Long-Time Microsoft User

That is why my frustration with Microsoft belongs in this essay. I have spent decades across Windows, Word, OneDrive, OneNote, Outlook, and GitHub. Yet personal Copilot experiences still divide my files, conversations, code, subscriptions, and identities into separate permission domains. The problem is not simply inconvenience. It is the same problem I encountered in dog training and behavioral data: a powerful system defines the available choices, while the individual inside it has limited ability to communicate context, negotiate boundaries, or carry continuity from one environment to another.

A Concrete Missing Feature: A Personal Archive Agent

A concrete example is a permissioned archive agent. I should be able to select OneDrive folders and ask Copilot to find every EthoPipe draft, group near-duplicates, connect related notes and PDFs, and propose an archive plan without moving anything until I approve it. Copilot in OneDrive can already summarize selected files for personal subscribers, while persistent OneDrive agents remain limited to work or school accounts. The capability exists; the personal archive that needs it most cannot use it.

Subscription Value and the Missing Middle

My Microsoft 365 Premium subscription was granted through the GitHub Education Student Developer Pack. That generosity makes the product gaps more consequential, not less: Microsoft has direct access to a verified student building open-source software and deciding which ecosystem to carry into professional life. Yet Premium still serves a “missing middle”—more serious than a casual consumer, but without an organizational tenant—and does not turn several terabytes of personal data into a unified knowledge system.

Google’s Student Strategy Is a Customer-Acquisition Masterclass

Google offers a useful contrast. Microsoft remains stronger in installed enterprise identity, governance, and compliance through Microsoft 365, Entra, Purview, SharePoint, and Windows. Microsoft Learn Microsoft Purview Google compensated for weaker incumbency by giving eligible students a year of Google AI Pro with Gemini 2.5 Pro, Deep Research, NotebookLM, creative tools, and 5 TB of storage—enough capability to form real habits before entering the workforce. Google Google Brazil

Microsoft owns an equally powerful channel in GitHub Education, but entitlement should be the beginning of the relationship, not the end. Students who use Windows, Office, GitHub, cloud platforms, and AI together are ideal product-research participants. Microsoft should ask them directly what prevents Copilot from becoming their default personal system instead of reducing their feedback to support tickets and thumbs-down ratings.

Account Friction: Verified as a Student, Treated as an Organization

The identity model created friction before I could evaluate the offer. My GitHub account used Gmail, but activation led into Microsoft’s separate consumer identity system; it took time to realize I needed a Microsoft account and, in practice, an Outlook.com address. The failure was not that distinct identities exist. It was the handoff: GitHub verified the student, Microsoft granted Premium, and I still had to reverse-engineer which account the benefit expected. Microsoft Support

After activation, that verified status did not become a durable education identity. Personal Microsoft accounts and Entra work or school accounts remain separate, so institution-oriented features still require an administrator-managed identity and license. Microsoft Support

Microsoft Learning Zone made the contradiction visible. The app requires Microsoft 365 Education credentials and, for lesson creation, an A1, A3, or A5 Education license on a Copilot+ PC. Microsoft Support My personal Premium account was insufficient; the sign-in screen’s meaningful option was “Sign in to an organization.” Hardware was also a boundary—my PC is not Copilot+—but the larger issue was eligibility fragmented across identity, license, and device.

When a Platform Bug Erases the Student Pathway

Azure made the fragmentation more consequential. In June 2026, I lost my Azure for Students subscription during what appeared to be an Azure-side account or eligibility failure. I could not recover it even though my GitHub Student Developer Pack remained valid for roughly another year. Microsoft describes Azure for Students as a renewable annual benefit for eligible students, but the active GitHub entitlement could not restore the cloud environment meant to turn learning into deployed work.

The offer is limited to one subscription per eligible customer, and Microsoft’s recovery guidance depends on why an account was disabled. Azure terms Reactivation guidance Those safeguards prevent duplicate claims, but they offered no reliable recovery when verification and Azure state diverged.

Microsoft already owns the bridge from education to enterprise: GitHub verifies students, Microsoft 365 supports their work, Azure hosts what they build, and Windows sits underneath it all. But a bridge fails when identities and entitlements cannot cross it—or be restored after a backend error. Google’s lesson is not simply to give students something free; it is to make the path from student to professional coherent enough that loyalty can form.

Notebooks That Do Not Yet Feel Like Knowledge Tools

Copilot Notebooks illustrate the same gap. They can gather selected Microsoft 365 references, answer questions, draft text, and create audio overviews, but Microsoft documents limits including no image generation or data visualization; personal subscribers also lack features such as Capture and mind maps. Microsoft Support Notebook FAQ

By contrast, NotebookLM supports broader source types, inline citations, study guides, and multimedia overviews, while Adobe Acrobat PDF Spaces turns document sets into reusable, cited workspaces and shareable outputs. Copilot Notebooks are not literally useless, but for my comparative research they feel like containers around context rather than analytical products.

Who Gets Asked What Copilot Should Become?

Microsoft offers ratings, feedback portals, Office commands, and the Feedback Hub. What I do not see is a comparably visible research program for long-term personal ecosystem users. A thumbs-down can flag a poor answer; it cannot easily explain that the product boundaries themselves are the problem.

Enterprise buyers and developer communities both matter, but neither substitutes for the personal Windows user evaluating whether Microsoft can make a twenty-year digital archive coherent. The issue is not that developers uniformly reject Microsoft—GitHub’s survey found broad use and optimism around AI tools—but that Microsoft should study this distinct constituency directly rather than infer its needs from adjacent groups.

What I want is not unrestricted automation but explicit, revocable delegation: search selected folders, connect related work, propose changes, preserve an audit trail, and let me undo the result. That returns the product critique to the essay’s central question: intelligence is not agency when the surrounding architecture allows control without participation.

The Ultimate Mirror: Temperature 0.0 and Radical Authenticity

The path from Morgan to EthoPipe to Microsoft is therefore not a collection of detours. Each exposed a different layer of the same architecture. Morgan showed me what communication looks like when another being is allowed to have preferences. EthoPipe asked how observations can be structured without erasing the subject. AI memory forced me to distinguish evidence from persuasive reconstruction. Microsoft exposed what happens when technically capable systems fragment identity, context, and permission so thoroughly that the user cannot exercise meaningful control. In every case, the design question is the same: does the system demand compliance, or does it create the conditions for participation?

For years, I felt unsafe communicating in traditional spaces. Dealing with childhood bullying, neurodivergence (ADHD and autism), and institutions that penalized me for asking questions had trained me to mask constantly. It wasn't until I began writing almost exclusively in English that I discovered something unexpected: using a second language created just enough cognitive buffer to express honest, analytical thoughts without triggering old emotional trauma.

Working with AI offered a similar kind of refuge. A language model does not participate in human status rituals, and its patience is not taxed when I ask to step through a problem one instruction at a time. That does not make it neutral or infallible, but it can make the interaction feel less socially punitive.

That dynamic mirrored the exact architecture of EthoPipe.

When we lower Gemini’s temperature to 0.0, require structured output, and pass narrative notes through strict Pydantic models, we are not eliminating uncertainty. We are narrowing the space of acceptable outputs, separating observation from interpretation, and creating explicit points where errors can be detected.

And that is exactly what Morgan was asking of me every single day.

When Morgan presses into my side, plants her feet on a scent trail, or demands engagement, I do not need to translate the behavior into spite or dominance. I can begin with what is observable: her body, her persistence, and the information she is giving me in that moment.

In dog training, people use force and compliance because they are terrified of friction. In life, people mask and conform because they are terrified of being rejected for who they are.

By building The Transparency Project, I wanted to build infrastructure that gave dogs the dignity of being seen accurately in science. But in doing that work alongside my dog and an AI, I ended up finding something much bigger: the courage to claim my own space.

Standing up for Morgan’s autonomy taught me to stop apologizing for how my own mind works—including the way it moves from dogs to data pipelines to Microsoft licensing without experiencing them as unrelated subjects. I follow the structure underneath them. Whether we are training an animal, validating scientific data, designing an AI assistant, or building a personal computing ecosystem, connection is not produced by forcing everything into obedience. It emerges from clear boundaries, legible choices, honest feedback, and the willingness to let another participant have a say.
ourselves.

The Paperclip That Arrived Twenty Years Too Early

Alice Severi Gonçalves — Tue, 15 Sep 2026 00:37:14 +0000

In the collective memory of personal computing, the conversation about Microsoft almost always circles back to a punchline. Someone brings up Windows Vista, someone else mentions Internet Explorer, and inevitably, everyone laughs about Clippy.

They remember the googly eyes, the frantic tapping against the inside of the monitor glass, and that patronizing prompt: "It looks like you’re writing a letter." To a generation navigating Office 97 in high-pressure cubicles on tight deadlines, he was an infuriating digital backseat driver.

My memory of that era has always looked fundamentally different.

I grew up with the privilege of running fully licensed, retail installations of Windows rather than cracked, fragile builds.
To a child sitting in front of Word 97, exploring an operating system purely out of curiosity, Clippit—his actual, forgotten name—was never an irritation.

He was an ambient companion who made the machine feel alive.

It took me years to discover that the rest of the world hated him.

Looking back with an understanding of software architecture, the tragedy of Clippit was not that the concept was foolish; it was that it was wildly premature.

Beneath the cartoon sprite lay Microsoft Research’s Project Lumière—an astonishingly ambitious effort to apply Bayesian probability to real-time human intent.

Decades before modern transformers, neural networks, or massive compute clusters, Microsoft attempted to build an agentic assistant that ran on single-core processors and sixteen megabytes of RAM. Clippit quietly observed keystrokes, calculated the statistical likelihood of your next action, and tried to surface relevant tools before you had to hunt through dense menus.

Where Clippit collapsed was not in his algorithmic ambition, but in the fragile psychology of interface design. Leaning into social-actor theory—the idea that humans instinctively anthropomorphize interactive technology—Microsoft gave the assistant an expressive face and physical gestures. But an agent that interrupts your workflow with moderate probabilistic accuracy is infinitely more aggravating than a static toolbar.

When Clippit guessed wrong, he did not fail discreetly. He broke your train of thought, seized the cursor, and demanded social bandwidth without possessing the semantic comprehension to earn it.
He was an ambient agent stranded in an era of manual tools.

Clippit was not intelligent.

He was not particularly accurate.

He was often distracting.

And yet, looking back, I find it difficult to laugh at him. Not because he succeeded, but because he was attempting something that the technology of his era could not possibly support.

The paperclip sitting beside a blank Word document in 1997 was trying to do something remarkably similar to what modern AI assistants are attempting today: understand intent, reduce friction, and help people work with
technology in a more natural way.

The difference is that Clippit was trying to achieve it with a fraction of the computing power, memory, data, and contextual awareness that modern systems take for granted.

For most people, Clippy became a joke. For Microsoft, he became a lesson.

The company spent the next three decades refining the same idea through different products and technological eras. Cortana taught Microsoft that users prefer to ask for assistance rather than have it imposed on them.

Copilot is teaching Microsoft how critical context, memory, and restraint are when coexisting with a user's workflow.

Seen from that perspective, Clippit was not a dead end. He was a prototype.

The paperclip failed so that future assistants could learn when to speak, when to remain silent, and how to fit naturally into the work people were already doing. Maybe that is why I still remember him so fondly.

When I was a child sitting in front of Word 97, Clippit felt like a glimpse of the future. At the time, that future never quite arrived.

Now, nearly thirty years later, I can open Word, work with Copilot, and watch an assistant help organize ideas, refine drafts, and recall context across past conversations. For the first time, that old vision feels technically possible.

And the more I think about it, the harder it becomes to see Clippit as a failure.

Perhaps he was simply the first draft.

About This Series: First Drafts of the Future

Rather than cataloging Microsoft through missteps, this series re-examines the visionary ideas Microsoft conceptualized years—and sometimes decades—before the hardware, software architecture, or user culture was ready to sustain them.

The AI Era: Democratizing the Ivory Tower and Reclaiming the Latin American Mind

Alice Severi Gonçalves — Sat, 18 Jul 2026 02:00:49 +0000

When you view the academic, professional, and technological worlds through the intersectional lens of a woman born and raised in the Global South, you quickly learn to look at every first-world narrative with absolute skepticism. For decades, the intellectual establishment of the global North has built massive, impenetrable walls around knowledge, dictating who gets to speak, who gets to write, and who counts as an authority. They have constructed an intricate system of gatekeeping designed to protect their prestige, maximize their fame, and extract the raw intellectual and natural resources of the rest of the world while leaving the creators in the footnotes.

For a long time, I lived with an intense, suffocating sense of self-doubt. I questioned whether my perspective was relevant, whether my observations had value, and even whether I had the right to claim the labels that describe my own existence. It is a common crisis of identity for those of us from Brazil. We trap ourselves in a bizarre linguistic limbo, wondering: Can I truly call myself Latina? Because first-world media and American-centric bureaucratic boxes heavily dominate global culture, the world has been conditioned to treat "Latino" as a concept synonymous only with Spanish speakers.

But this is a superficial, historically illiterate flattening of our reality. The very word "Latino" traces its lineage directly back to the Latin language of the Roman Empire, the root from which all Romance languages evolved. Spanish is a Latin-derived tongue, but so is Portuguese. To deny a Brazilian woman her identity as a Latina is to succumb to a geographic and administrative distortion invented by first-world institutions to simplify their demographics. Brazil is the largest, most populous, and geographically dominant nation in Latin America. When we claim the title of Latina, we are not borrowing a Spanish word; we are reclaiming our geography, our history, our language’s Roman lineage, and our collective place in the historic struggle against institutional exclusion.

The fact that we feel we must ask permission to use a word that defines our own home continent is the ultimate proof of how deeply the gatekeepers have succeeded. They have not only monopolized international publishing, funding loops, and prestigious prizes; they have colonized our internal sense of worth. When you look at the history of science and medicine, you realize this pattern of systemic extraction and erasure is centuries old.

The Footnotes of Empire: Ferreira, Chagas, and Finlay

The history of first-world academic prestige is a history of extraction. They take our raw data, our clinical observations, and our natural resources, process them through the rigid machinery of Western institutions, and brand the final product with a first-world trademark.

Consider the tragic case of Dr. Sérgio Henrique Ferreira. In the 1960s, working out of the University of São Paulo in Ribeirão Preto, Dr. Ferreira conducted brilliant, foundational research on the venom of the Bothrops jararaca pit viper. He succeeded in isolating the Bradykinin-Potentiating Factor (BPF), a discovery that unlocked the molecular mechanics of blood pressure regulation. This exact molecule became the indispensable biochemical blueprint for Captopril, the world’s very first ACE inhibitor, which went on to revolutionize cardiology and save millions of lives across the globe.

Yet, when Ferreira traveled to London to collaborate with his colleague Sir John Vane, co-authoring pioneering papers that mapped how aspirin inhibits prostaglandins to treat pain, the historical script played out precisely as written. In 1982, John Vane was awarded the Nobel Prize in Physiology or Medicine for those exact discoveries. The British supervisor received immortal glory, historical statues, and global fame, while the brilliant Brazilian mind whose hands-on expertise and venom-derived mechanics fueled the breakthrough was left out of the spotlight, transformed into an invisible column in an institutional ledger.

This pattern repeats across what the West patronizingly labeled "tropical medicine"—a term historically used to ghettoize the medical brilliance of the Global South as exotic and localized, rather than universal. In 1909, working inside a modified railway car in the interior of Minas Gerais, Carlos Chagas achieved a medical triumph that no European or American scientist had ever accomplished before, and none has duplicated since. He single-handedly discovered, isolated, and fully described a completely new infectious disease. In a single, historic sweep of independent execution, Chagas identified the parasite (Trypanosoma cruzi), the insect vector (the barbeiro), the domestic animal hosts, and the entire clinical manifestation of the disease that now bears his name. He was nominated for the Nobel Prize in 1913 and 1921. He never won. The Eurocentric committees simply could not stomach awarding the highest badge of scientific immortality to a Brazilian doctor working with a shoestring budget out of a train car.

We see the exact same corporate and academic gaslighting in the story of Cuban physician Carlos Juan Finlay. In 1881, Finlay discovered that yellow fever was not an airborne miasma, but a vector-borne disease transmitted specifically by the Aedes aegypti mosquito. For two decades, the elite medical establishments of Europe and the United States openly mocked him, dismissing his vector theory as an unscientific, backward colonial delusion. Decades later, when the U.S. Army Yellow Fever Commission led by Walter Reed arrived in Havana, they used Finlay's exact data, adopted his exact mosquito-breeding methods, confirmed his thesis, and claimed the absolute credit. Today, first-world textbooks worship Walter Reed as the heroic conqueror of yellow fever, while Finlay is pushed into the shadows of the historical narrative.

Worshiping the Gods of Condescension: Darwin and Einstein

We are trained to revere these institutions and their foundational giants, yet if you open the private notes of the men whose statues decorate first-world universities, their unfiltered colonial disdain for our people becomes glaringly obvious.

Take Charles Darwin, who is canonized in first-world textbooks as a saint of progressive thought and a fierce abolitionist who detested slavery. It is true that he wrote with absolute horror about the human atrocities he witnessed enslaved people suffering in Rio de Janeiro and Pernambuco. But academia completely hides his secondary worldview. When you open his private diaries from his time in Rio, specifically his entry on July 3, 1832, his Eurocentric, aristocratic bias is completely unfiltered. He wrote that the local Brazilians were:

“Ignorant, cowardly, & indolent in the extreme... contented with themselves & their customs, they answer all remarks by asking ‘why cannot we do as our grandfathers before us did’.”

He dismissed an entire population as naturally lazy and backward simply because they did not live, think, or perform according to 19th-century British standards.
Fast forward nearly a century later to May 1925, and you see the exact same toxic elitism from Albert Einstein during his week-long visit to Rio de Janeiro. To the Brazilian public, his visit was a monumental event; local scientists, doctors, and politicians treated him like a visiting deity, packing lecture halls and hosting grand banquets in his honor. But when Princeton University Press published The Travel Diaries of Albert Einstein: South America, 1925, his private thoughts were laid bare. Before even setting foot on the continent, Einstein wrote a letter to a friend complaining about the journey, stating: “I have no desire to meet semi-acculturated Indians wearing tuxedos.” Once there, surrounded by Brazilian academics who revered him, he wrote a cynical, chilling line in his diary:

“Here I am a kind of white elephant to the others, they are monkeys to me.”

He even went out of his way to privately refer to Dr. Aloysio de Castro—the highly respected, brilliant head of the Faculty of Medicine in Rio—as “a real monkey.” Einstein was actively operating under the pseudo-scientific racist framework of "geographical determinism"—the colonial belief that living in hot, humid tropical climates naturally "softened" human cognitive faculties, rendering people of the Global South inherently inferior to Europeans.

Hearts Carved from Grit: Surgical Mastery vs. First-World Budgets

But history completely exposed their intellectual arrogance. While the giants of the West were busy writing us off as cognitively compromised by the tropical heat, our clinicians and surgeons were quietly redefining modern medicine. We did not have their multi-million-dollar endowments, their imperial laboratories, or their structural safety nets. What we had was raw intelligence, spatial geometry, and unmatched grit under pressure.

Because our medical systems operated under severe resource deficits, our doctors had to master the absolute peak of clinical execution. We became global masters of the most delicate, volatile, and unforgiving domain of medicine: surgery.

It was the brilliant Argentinian surgeon Dr. René Favaloro who revolutionized global cardiac care by inventing the modern coronary artery bypass graft surgery using the saphenous vein. His structural breakthrough continues to save millions of human lives every single year across every continent on Earth. It was the Brazilian surgeon Dr. Euryclides de Jesus Zerbini who, in 1968, performed the first heart transplant in Latin America and the third in the entire world. He executed a complex surgical intervention of stunning difficulty at a standard that the elite medical circles of Boston and London were forced to respect.
We have always possessed an extraordinary, highly sophisticated scientific and manual capacity; we were simply denied the infrastructure, the funding loops, and the imperial prizes meant to validate it.

The Hidden Curriculum: Prepping for the Mongrel Complex

The most insidious element of this global gatekeeping is that it forces us to internalize our own exclusion. I experienced this firsthand growing up in Brazil. My parents paid for me to attend elite, high-tier private schools like Objetivo—institutions explicitly designed to prepare the children of the comfortable class to pass rigid academic entry exams. You would assume that a premium, highly paid education would offer a perspective of national pride and historical grounding. The opposite was true.

The entire hidden curriculum of those expensive classrooms implicitly conditioned us to believe our own country was an inherently broken, backward, and hopeless void. It was the ultimate systemic execution of what the great Brazilian writer Nelson Rodrigues called the complexo de vira-lata (the mongrel complex)—the collective psychological trauma where we voluntarily place ourselves at the feet of the Global North, automatically assuming that everything they produce is superior, civilized, and true, while everything we generate is primitive and flawed.

Nobody in those private schools ever felt the need to look us in the eye and tell us how brilliant our history was, or what our scientists had actually built. They trained us to memorize first-world templates for validation, leaving me to rescue myself and discover our rich scientific legacy later in life, entirely by myself. If our own premier national institutions train us to apologize for our intellect, why should we expect first-world academic structures to wear anything but a mask of exclusion? The Ivory Tower has always been an exclusive club with very high walls.

The AI Sanctuary: Outsourcing Noise and Escaping Human Egos

This is why the current, frantic panic over Artificial Intelligence is so profoundly fascinating to watch. Suddenly, the academic and media elites of the internet are terrified of intellectual dishonesty and the loss of critical thinking. They scream about copyright, data scraping, and the dilution of human integrity, as if the traditional human systems they are defending weren't already plagued by systemic theft, extraction, plagiarism, and gatekeeping long before the first line of AI code was ever compiled.

While I agree with valid technical critiques regarding environmental resource consumption and algorithmic bias, the loudest moral outcries haven't convinced me. Bad work, cheating, performative posturing, and structural injustice are human traits, not the fault of the code. They will always exist with or without the algorithm. The current tech panic isn't about protecting "truth"; it is about human ego. The academic elite is terrified because they are losing their historic monopoly on authority, their control over information, and their fame. Everyone on social media wants to scream louder than the rest, posing as the next Socrates, while forgetting that true knowledge meant to better the world doesn't need a public relations campaign.

For me, as a neurodivergent Latina navigating these rigid human systems, the reality of AI is deeply personal and transformative. Living with ADHD and Autism means my brain operates as a bottom-up pattern-recognition engine, producing a relentless, exhausting amount of internal cognitive noise.

I live in a perpetual loop of self-doubt, manually analyzing my environment, trying to predict unspoken social expectations, and managing the hyper-volatile emotional states of the people around me—a process that ultimately leads to severe burnout. I was never built for their neurotypical social standards.

In a world like that, interacting with a Large Language Model provides a profound baseline of psychological relief. Because the algorithm processes data mathematically rather than emotionally, it possesses no ego to bruise and no social status to protect. I can ask a machine a dense technical question without a human getting defensive, getting emotional, or assuming I am defying their authority. It is an objective sanctuary where I am completely free from the fear of being bullied, judged, or socially penalized just for wanting to learn and understand. Far from encouraging intellectual laziness, this friction-free loop has allowed my critical thinking to explode. It acts as an executive function exoskeleton, handling the structural heavy lifting of syntax and linear organization so my raw, systemic logic can handle the architecture of the project.

High-Dimensional Spaces and the Equalizing Algorithm

For a non-native speaker, staring at a blank screen is rarely a symptom of a missing idea; it is the paralyzing, resource-heavy drag of an inefficient translation loop. When I write, my mind is forced to run a constant background cycle: first, gathering the hyper-detailed, non-linear patterns of my observations in Portuguese, and then forcing those concepts through the rigid bottleneck of standard corporate English syntax.
When you look past the chatbot interface and understand the underlying data science, you realize why AI shifts this paradigm entirely. Before an LLM processes a single token, it maps language into high-dimensional vector spaces called text embeddings.

[Raw Human Thought / Intent]
            │
            ▼
[High-Dimensional Vector Space]  <─── Maps pure semantic meaning mathematically
            │
            ▼
[Target Language / Syntax Output]

In this mathematical space, words are converted into coordinate vectors where concepts with similar meanings cluster together based on their actual semantic relationships and universal human definitions, entirely divorced from regional prestige, accents, or institutional status. It maps the pure geometry of human thought.

The empirical data proves that this mathematical floor is actively working as a powerful tool for global justice. A massive study evaluating the impact of Generative AI analyzed the stylistic evolution of 5.6 million scientific papers authored by teams across non-English-speaking countries. The researchers tracked linguistic similarity to international publishing benchmarks and discovered that following the public release of ChatGPT, papers authored by scientists from non-English-speaking countries saw a massive, rapid convergence toward standard publishing standards.
Crucially, this equalizing effect was strongest for domestic co-author teams and researchers working in countries linguistically far from English—the exact groups that face the highest risks of peer-review bias and completely lack the massive capital required to pay for expensive first-world translation and editing services.

The algorithm didn't do the thinking for these scientists; it gave their existing, brilliant thinking a linguistic exoskeleton, allowing their ideas to stand on their actual scientific and empirical merit rather than their author's native tongue or academic pedigree. It allows an independent operator in South America to completely bypass the peer reviewers who would historically reject a revolutionary paper simply for "awkward wording."

Critics love to counter that these tech conglomerates are unethical because they scraped our collective "content, information, and lives" to train their models without explicit permission. But honestly? The Global North has been copying, stealing, and extracting our concepts, our history, and our natural venom for centuries without asking. Personally, I don't possess millions in corporate assets or classified state secrets. Let them scrape my data. If my digital footprint helps fuel a machine that acts as a linguistic equalizer—allowing a marginalized kid from a broken background to write an essay or compile a piece of code that can smash through a biased gatekeeper—it is a trade-off I am entirely willing to make.

I used to carry a deep, quiet regret about leaving my formal academic life behind. I used to look back and wish I hadn't given up, believing that if I had only stayed inside those traditional walls, I could have built something meaningful. I used to think my voice from the outside was completely irrelevant. But looking at this massive technological shift, I realize that a perspective from the outside is exactly what is needed. AI isn't ruining the intellectual world; it is exposing the fact that the Ivory Tower was always built on a foundation of exclusion. The walls are finally coming down, and we don't need their permission to speak anymore.

How I Survived the Silent AI Upgrades (And Shifted My Workflow)

Alice Severi Gonçalves — Fri, 17 Jul 2026 20:27:00 +0000

The Day the Premium Quotas Melted

We’ve all seen the massive marketing headlines celebrating multi-million token context windows. So when I scored access to the Google AI Pro student tier, I figured I was completely set.

My journey into the anatomy of a prompt didn’t happen overnight; it started a while back when I was experimenting with visual generation in Adobe Firefly. By August of last year, I got deep into language models, eventually using them to power through my EBAC programming course and moving my coding workflows directly into Antigravity IDE. Over nearly a year of continuous, everyday use, I learned exactly how these systems tick. As an aspiring developer, I optimized my prompts, mapped out constraints, and treated the LLM like a highly predictable engine to accelerate my learning.

Naturally, I put my established setup to the test. I uploaded my personal documentation, technical archives, and coding references into the newly rebranded Gemini Notebook (formerly NotebookLM), running Flash Extended to handle the retrieval. I wasn't even running heavy Pro-level operations—just a routine pass to extract milestones and start drafting a profile.

Then, I asked a few formatting questions, checked my usage dashboard, and watched in pure disbelief as 50% of my rolling 5-hour compute quota completely evaporated in a matter of minutes.

I hadn't changed my source files. I hadn't switched models mid-session. But the architectural ground shifted anyway. Here is exactly what is happening under the hood with these silent AI infrastructure rollouts, and how a junior dev's workflow had to change overnight to survive the token crunch.

1. The Background Agent Tax

We used to think of Large Language Models as linguistic calculators—they predicted the next most probable word based on pattern matching.

But with recent infrastructure upgrades, the underlying architecture has evolved into something much more complex. When you ask a modern AI assistant a complex analytical question over your documents, it doesn't just read the text anymore. The system silently provisions a secure cloud computer, writes a custom Python script to parse your sources, executes it, and formats the output.

Because the Gemini ecosystem now shares parts of the same agentic code-execution harness used by Antigravity IDE, it treats your documents like an active environment. While this makes the AI incredibly precise and practically eliminates linguistic math hallucinations, it comes with a massive compute surcharge. Every background execution loop, sandboxed environment state, and data variable has to be held in the active context window. You aren't just paying for the words you read; you are paying the operational runtime of a background software engineer.

2. Aggressive Context Slicing

To prevent web interfaces from lagging under the weight of these massive agentic loops, consumer applications are quietly implementing context slicing and extreme text compression behind the scenes.

Once your conversational history crosses a certain threshold or accumulates too many background code-execution logs, the interface stops passing the entire thread to the model. Instead, it relies on silent retrieval chunks. This is why an AI you’ve been working with seamlessly for an hour will suddenly "forget" a critical formatting rule or a core naming convention you established in prompt #2.

My New AI Survival Blueprint: Ecosystem Hopping

To keep my workflows efficient and stop burning through my daily student compute caps by noon, I’ve completely restructured how I interact with LLMs. The secret? You have to jump across different Google products strategically to keep your tokens alive.

Separating Extraction from Iteration: I no longer do creative drafting or iterative formatting inside data-dense notebooks. I use the notebook once to let the agent parse the files and extract a clean, structured text baseline or chronological milestone list.
The "Clear Slate" Migration: Once I have that raw text block, I copy it out, close the heavy workspace entirely, and paste it into a completely fresh, standard chat window. By decoupling the heavy data-parsing engine from the creative-writing layer, my compute footprint drops to near zero.
Graduating to Developer Environments: For complex programming or tracking intricate data structures where memory loss is a project-killer, I step outside the consumer web wrappers and jump into Google AI Studio. Getting raw model access gives you deterministic control over your context window and absolute visibility over your exact token count, completely bypassing the aggressive background agent surcharges.

The Takeaway: AI isn't just getting bigger; it's getting hungrier. Even if you've spent a year mastering the tool, hold premium tier access, and use it to power through coding bootcamps, if you don't actively manage your context architecture, the infrastructure will manage it for you—usually at the expense of your active memory. As developers, our job isn't just to write code; it's to understand the systems we build upon. And right now, navigating the AI layer demands a completely new style of resource management.