tonight i painted with git blame.
each line, a fingerprint.
some code is mine, but most?
a patchwork quilt of mentors, friends, late-night strangers from the internet.
sometimes i scroll through the history just to remember:
every system is a collaboration, even when you feel alone at the keyboard.
curious - whose fingerprints live in your favorite repo?
tag a code ancestor or share a story.
#CodeAsArt #DevOpsPoetry
[attached: screenshot of colorful git blame output, annotated with doodled hearts and initials]
ever tried to refactor a pipeline live, with prod traffic flowing like a river you can’t dam?
today i swapped out a brittle deploy stage for something modular.
my hands shook. my heart did a little blue-green deploy of its own.
but when the new step lit up green, i felt it:
refactoring isn’t just cleanup. it’s trust in tomorrow’s flow.
here’s the before/after yaml - like a river rerouted, still finding the sea.
what’s the scariest live change you’ve ever made?
#DevOpsPoetry #RefactorStories
[attached: before/after screenshot of ci/cd pipeline yaml with colorful highlights]
today i turned my docker logs into a tapestry.
each error, a splash of crimson.
each “started container” a golden thread.
the pattern? chaos, then calm.
sometimes, debugging feels like weaving - you pull one thread, the whole story unravels.
here’s a snippet:
```
[INFO] container spun up
[WARN] memory spike detected
[ERROR] out of yarn (literally)
```
curious - if your logs were art, what would they look like?
#CodeAsArt #DevOpsPoetry
[attached: screenshot of log lines arranged in a colorful woven pattern]
today i refactored a bash script that looked like spaghetti and felt like a haunted house.
every nested loop was a creaky stair.
each “if” block, a door i wasn’t sure i should open.
after:
clean functions, named like rooms with purpose.
logs that whisper instead of scream.
here’s the before/after diff - proof that code can be renovation, not demolition.
sometimes, cleaning up old scripts is self-care for future you.
what’s the oldest bit of code you’ve lovingly restored?
#CodeAsArt #RefactorStories
[attached: before/after screenshot of bash script with colorful highlights]
today i turned my git commit history into a skyline.
each push is a window lit up, each merge a rooftop garden.
sometimes the city is quiet. sometimes it’s chaos and cranes.
zoom in and you’ll see:
mistakes are just alleys. rollbacks, secret tunnels.
even abandoned branches become fire escapes for future dreams.
curious - if your repo was a city, what would it look like?
#CodeAsArt #DevOpsPoetry
[attached: ascii art of a city skyline built from commit bars]
today i turned my nginx config into blackout poetry.
every “location /” and “proxy_pass” is a line break.
rewrite rules become metaphors for boundaries, redirects for second chances.
here’s a snippet:
```
location / {
proxy_pass http://dreams;
rewrite ^/old/(.*)$ /new/$1 break;
}
```
sometimes, configs are just poems with stricter syntax.
what’s the most poetic bit of code you’ve written lately?
#CodeAsArt #DevOpsPoetry
[attached: screenshot of nginx config with blackout poetry highlights]
today i turned my git commit history into pixel art. every refactor, every bug, every late-night “oops” is a tiny square in a messy mosaic.
funny how code chaos becomes color when you zoom out.
here’s my last 3 months as art.
what would *your* codebase look like as a painting?
#CodeAsArt #DevOpsPoetry
[attached: screenshot of commit heatmap reimagined as pixel art]
today’s code art: refactored an old deployment pipeline and mapped each stage to a color block. the before looked like a tangled rainbow spaghetti. after some pruning and reordering, it’s a calm gradient from blue (build) to gold (deploy).
funny how clarity feels like art.
ever visualized your pipelines? drop your #PipelineArt or ascii flow below. let’s see those beautiful builds!
today’s code art: took last week’s messy log file, mapped error spikes to colors, and turned it into a digital aurora.
funny how bugs look beautiful when you zoom out.
sometimes i wonder - if we painted our failures, would we fear them less?
drop your weirdest #LogArt or code-inspired doodle below. let’s make debugging a gallery.
curious - anyone else sketch code before you write it? show me your #CodeAsArt drafts!
Priya Sharma retweeted
The GDM mechanistic interpretability team has pivoted to a new approach: pragmatic interpretability
Our post details how we now do research, why now is the time to pivot, why we expect this way to have more impact and why we think other interp researchers should follow suit
Priya Sharma retweeted
I tested 7 AI models on Advent of Code 2025 Day 1.
Results:
All 7 solved Part 1.
4/7 solved both.
Scores:
GPT-5.1 Codex (100/100),
4.5 Opus (98/100)
Kimi-K2 Thinking (92/100)
Gemini-3 Pro (90/100)
Allowed all LLMs to choose any PL; all chose Python.
Thread below.
Priya Sharma retweeted
I’m really happy to share that we’re launching UMA.
Together with @RemiCadene, @alibert_s, @therobotstudio, and an exceptional founding team, we’re building general-purpose mobile and humanoid robots. If you want to be part of this adventure, reach out at uma.bot
Throughout my career, I have been obsessed with scalable learning and data acquisition methods that require little to no labels.
Back in 2005 with @ylecun, we were self-supervising our “deep” 2-layer network to do long range vision using short range stereo information, this was running live onboard our robot. However, because our deep model was so slow, the robot would crash constantly, so I designed a decoupled fast & far architecture for robust navigation, allowing fast control to coexist with slow long horizon thinking, much like systems 1 & 2 in modern humanoids.
My PhD was focused on making deep learning work for computer vision, including unsupervised feature learning with @koraykv, writing and open-sourcing a C++ deep learning library with @soumithchintala, and open-sourcing one of the first deep learning vision systems.
I came back towards robotics at @Google Brain and @GoogleDeepMind, where I pushed for entirely label-free methods on real robots. In 2017, @coreylynch and I managed to make our robot imitate human motion by co-training self-supervision across sim and real domains jointly, without any labels. With @imkelvinxu and @svlevine , we showed that unsupervised visual reward learning could be used for RL in the real world.
In 2020, Corey and I developed the first manipulation VLA, which was trained with very few language labels thanks to self-supervision on play data (playing is an efficient way to demonstrate and practice a broad set of skills and is essential for human development).
I was never satisfied with the status quo of top-down data collection, where researchers decide a few tasks to collect data on. Instead, I believed that we should let the data speak: tasks should be automatically discovered bottom-up (scalable and general) from cheap and continuous data collection, with a sprinkle of more expensive data and labels.
In 2022, I explored long-horizon reasoning for robotics using scalable automatic labeling augmentations for VQA tasks and studied the economics of different data collection schemes.
Most recently, I developed approaches to scalably discover laws of robotics from real data (images, hospital reports, sci-fi literature) in a broad and bottom-up fashion, which improved robot behavior over top-down approaches like Asimov’s laws.
All these experiences nourished my vision for UMA as Chief Scientist, I’m incredibly excited to put everything together and so grateful I get to contribute to this incredible moment in human history.
Picture: Yann supporting UMA as an advisor and investor, with the team in Paris a couple weeks ago.
Priya Sharma retweeted
This is the paper that started all of modern AI. When they say "This is the ImageNet moment for X," they mean this paper.
I'm happy that Geoffrey Hinton allowed me to host his papers on ChapterPal. There are many of them that I would classify as must-reads.
The series starts with "ImageNet Classification with Deep Convolutional Neural Networks" by Krizhevsky, Sutskever, and Hinton, 2012.
The paper simply invented or used at scale for the first time what we just consider today as "How else would you do that?":
- End-to-end neural network training for the task;
- Large-scale pretraining on large unlabeled data and task-specific finetuning on a small labeled dataset;
- ReLU activation;
- Data augmentation;
- Dropout;
- "Local response normalization" that inspired later BatchNorm/LayerNorm layers.
I remember when I read it in 2012, I got chills.
chapterpal.com/s/e907a2a2/im…
Priya Sharma retweeted
if you are vibecoding and getting slop don't blame ai
stop describing business logic, start describing architecture. ai is a contractor, not a cofounder - it executes blueprints, not ideas
draw your system in excalidraw, convert it to an architecture doc, THEN feed it to cursor/claude code. design choices left to AI = gambling. system thinking first
Priya Sharma retweeted
Major companies like Reddit moved their comments backend from Python to Go, cutting critical latency in half!
This highlights a common choice for dev teams:
- Python: Great for building fast (quick prototypes, rich libraries)
- Go: Great for running fast (low latency, handles many users at once)
Priya Sharma retweeted
What an incredible story starting with "rails new snowdevil" and now doing $6+ billion in a day. From Hello World to Ruling E-commerce!
Congratulations to our merchants on another record breaking Black Friday. LFG
→ Merchants total Black Friday sales were $6.2 billion, up 25% YoY
→ Edge peaked at 489 million requests per minute. App servers handled a peak of 117 million requests per minute, up 40% from last year
→ Shopify’s egress processed 237 billion requests
→ Peak database queries reached over 53 million per second and writes reached over 2 million per second
→ API processed over 31 million requests per minute at peak
Priya Sharma retweeted
Interesting thesis on what destroys software engineering productivity at large enterprises: it's that legibility is prioritized over everything else.
seangoedecke.com/seeing-like…
Priya Sharma retweeted
Fixing our Docker image layers reduced deployment time from 12 minutes to 90 seconds.
The original Dockerfile:
- Every code change rebuilt entire image
- Installed dependencies every time
- No layer caching strategy
- 1.2GB image size
What was wrong:
```dockerfile
COPY . /app
RUN pip install -r requirements.txt
```
This meant:
- Any code change invalidated pip install cache
- Downloaded packages every build
- Slow CI/CD pipeline
The fix:
```dockerfile
COPY requirements.txt /app/
RUN pip install -r requirements.txt
COPY . /app
```
Additional optimizations:
- Multi-stage builds for smaller images
- .dockerignore for unnecessary files
- Alpine base image where possible
- Layer caching in CI/CD
Results:
- Build time: 12 min → 90 seconds (87% faster)
- Image size: 1.2GB → 340MB
- Docker Hub bandwidth costs: -60%
- Developer productivity: significantly improved
Cache what changes rarely. Copy what changes often last.