标签：#career

TL;DR Tech has taught me many things over the years. It taught me how to learn new technologies, build projects, apply for opportunities, and keep growing. What it didn't teach me was something that turned out to be just as important: how to take care of myself while doing all of those things. For a long time, I believed I would slow down later. Later, when life became less busy. Later, after the next project. Later, after the next opportunity. The problem was that "later" never seemed to arrive. It took an unexpected pause in my own life to realize that building a successful career means very little if we forget to take care of the person trying to build it. Looking back, I don't see that experience only as a difficult chapter. It changed the way I think about success, growth, and what it means to build a career that's sustainable. Today, I still love learning, building, writing, and chasing opportunities. None of that has changed. What has changed is the realization that taking care of myself isn't something separate from my career. It's one of the reasons I'll be able to keep building it for years to come. Along the way, I also realized that many of the things that truly support us are easy to overlook. Rest, movement, nourishing ourselves well, meaningful relationships, and simply checking in on the people around us often receive far less attention than the next framework, project, or milestone, even though they make everything else possible. More than anything, I wanted to write this because I care deeply about this community. I hope none of us have to wait until life forces us to slow down before remembering to take care of ourselves. I hope we build careers we're proud of, but I hope we also build lives we're able to enjoy. This isn't an article about productivity or health advice. It's simply a reflection on something I wish I had understood earlier. Your career matters. So does the person building it. I'd also love to hear your story. Has there been a momen

The Evolution of Junior Developer Roles in the Age of AI In the tech industry, a pressing question has emerged: Is the role of junior developers disappearing? With the rapid advancement of artificial intelligence (AI), particularly generative models like ChatGPT, there's growing concern about the future of entry-level software development jobs. While some predict a decline, the reality is more nuanced. AI is transforming these roles, not eliminating them, creating new opportunities for junior developers who adapt to the changing landscape. TL;DR AI advancements are reshaping junior developer roles rather than removing them. AI tools reduce the need for routine coding tasks but create opportunities for those focusing on higher-order skills like problem-solving and collaboration. Junior developers should embrace AI tools to enhance creative problem-solving. Companies must adapt talent strategies to nurture junior developers for future senior roles. The Transformation of Junior Developer Roles AI's Impact on Routine Coding Tasks Artificial intelligence has significantly automated routine coding tasks. AI models, such as ChatGPT, can generate code snippets, debug errors, and optimize performance. This capability shifts junior developers' focus from these tasks, traditionally a large part of their responsibilities. Code Generation : AI can produce boilerplate code, reducing the time spent on repetitive tasks. Error Detection : AI-driven tools identify and propose fixes for common coding errors, streamlining debugging. Performance Optimization : AI algorithms can automatically enhance code efficiency, which previously required manual intervention. Changing Nature of Junior Developer Roles The employment rate for junior developers aged 22-25 has declined nearly 20% from its peak in 2022. This trend indicates a shift in how entry-level positions are perceived and utilized within tech companies. With AI handling routine tasks, the role of a junior developer is evolving to em

We have all been there. You walk into a room full of tech enthusiasts, the ambient noise is humming...

Artificial Intelligence has changed the way we write software, but one thing has become clear: AI is a collaborator, not a replacement. After using coding assistants for months, I've realized they're best at handling repetitive tasks: Generating boilerplate code Explaining unfamiliar APIs Refactoring existing functions Writing documentation Creating unit tests Finding bugs faster Where AI still struggles is understanding the bigger picture. It doesn't know your product vision, business requirements, or why one architectural decision is better than another. Those are still human problems. The most productive workflow isn't asking AI to build an entire application from scratch. It's treating AI like an experienced teammate that can help with implementation while you stay responsible for the design and direction. The developers who will thrive over the next few years won't necessarily be the ones writing the most code—they'll be the ones asking better questions, validating AI-generated solutions, and combining technical knowledge with critical thinking. AI is changing software development, but it's also raising the value of good engineering judgment. How has AI changed your development workflow? What's one task you now almost always delegate to an AI assistant?

1:00 AM to 2:27 AM. One bug, three root causes, zero clean error messages. It started with a simple complaint: an admin sends a push notification, and the user never receives it. No crash, no red error in the console, nothing obviously broken. Just silence on the other end. That kind of bug is the most frustrating kind. Everything looks like it's working. The permission prompt shows up fine. The admin panel says "sent." And yet nothing arrives. By 1 AM, after a long day already spent on a fairly large project, this was the last thing left to fix before calling it a night. It turned into an hour and a half of tracing one silent failure into another. Layer One: The CSP Was Blocking the Fix Before It Could Even Start The first clue showed up in the browser console: a Content Security Policy violation, quietly blocking a script that OneSignal's SDK needed to complete its own initialization. The permission popup looked completely normal, so it was easy to assume the subscription step was working. It wasn't. The script that OneSignal used internally to finish setting up the subscription was being blocked by the site's own security headers. The fix was small: add the missing domain to the script-src directive. But finding it meant not trusting what the UI looked like it was doing, and instead reading the actual network requests line by line. Layer Two: "Sent" and "Delivered" Are Not the Same Thing Once the CSP was fixed, notifications appeared to send successfully. The API returned a success response, an ID was created, and the admin panel showed a "sent" confirmation. Except the user still got nothing. This turned out to be a subtler problem. OneSignal's newer API doesn't return a recipient count in that initial response, so a message could be "created" successfully by OneSignal's servers while still reaching zero actual devices. The code was treating message creation as proof of delivery, which is not the same thing at all. The fix involved polling OneSignal's delivery-s

Okay so. Story time. Grab a coffee; this one's got a body count. A few months back I got assigned a...

"Forward Deployed Engineer" went from a Palantir-specific title to one of the hottest roles in AI in about eighteen months. But nobody had actually counted the market, so I did. I pulled every open FDE role I could find from public ATS job boards (Greenhouse, Lever, Ashby) across 11 companies and analyzed all 292 of them. Here is what the data says. Who is hiring Three companies account for 250 of the 292 openings: Palantir: 95 (they coined the title, and still call many of these roles "Deployment Strategist") Databricks: 85 OpenAI: 70 Then a long tail: Cohere and Scale AI (13 each), Sierra, Writer, Modal, Baseten, Ramp, and Sardine. What it pays Of the 40 roles that disclosed a US pay band, the median ran $197K to $294K , topping out at $390K plus equity at OpenAI and Sierra, with a floor around $137K. That is senior-software-engineer money for a role a lot of engineers have never heard of. International and most Palantir roles did not publish bands, so the true market is likely even broader. Three things that surprised me 1. 98% of these roles are customer-facing. This is the defining trait. It is not a backend role with occasional meetings. It is an engineer who lives in the customer's world, and if that sounds terrible to you, this is not a role you would enjoy occasionally. It is the whole job. 2. The title is chaos. The same role goes by at least four names: Forward Deployed Engineer (152), Forward Deployed Software Engineer (58), AI or Deployment Engineer (43), and Deployment Strategist (36). If you only search one term, you miss most of the market. 3. The job descriptions undersell the technical bar. JDs emphasize customer-facing work, cloud (AWS/GCP/Azure), Python, and integrations. But SQL and algorithms show up in only about a third of them, even though every FDE loop I have seen tests live coding and SQL under time pressure. The description sells the breadth. The interview tests the depth. The other details Geography: about 48% USA, but genuinely global

If you want remote job data, you do not need to scrape HTML or sign up for anything. Four of the bigger remote job boards publish keyless public feeds. The catch is that they all speak different dialects, so the real work is normalization. Here are the endpoints and the traps. The four feeds RemoteOK returns its whole current board as one JSON array: GET https://remoteok.com/api The first element is a legal notice, not a job: they ask for a link back with attribution as a condition of using the feed. Skip element zero, and honor the attribution if you republish. Jobs carry salary_min and salary_max as numbers, tags, and ISO dates. Remotive has the friendliest API of the four, including server side search: GET https://remotive.com/api/remote-jobs?search=python&limit=100 Salary here is free text ( "$120k - $160k" ), so do not expect numbers. Attribution with a link back is required here too. WeWorkRemotely publishes RSS: GET https://weworkremotely.com/remote-jobs.rss Two quirks: the company name is not a field, it is baked into the title as Company: Role , so split on the first colon. And useful data hides in nonstandard tags like <region> , <skills> , and <category> that generic RSS parsers drop on the floor. Himalayas has a proper paginated API with a surprisingly deep catalog (100k+ listings): GET https://himalayas.app/jobs/api?limit=100&offset=0 It gives structured minSalary / maxSalary with a currency and period, seniority arrays, location restrictions, and even timezone restrictions as UTC offsets. Dates are epoch seconds, not ISO strings. The normalization layer The row schema that survived contact with all four sources: { "source" : "Remotive" , "title" : "Senior Backend Engineer" , "company" : "Acme Corp" , "tags" : [ "python" , "aws" ], "salaryMin" : null , "salaryMax" : null , "salaryText" : "$120k - $160k" , "location" : "Worldwide" , "postedAt" : "2026-07-03T20:01:13.000Z" , "applyUrl" : "https://..." } Rules that mattered in practice: Keep both salary sh

Why Your SOE Resume Needs a Structural Overhaul Chinese state-owned enterprises (SOEs) often have deep hierarchical structures and a culture of collective achievement. But Western tech companies want to see individual impact, autonomy, and data-driven results. Continuing to lead with your former employer's prestige or your rank (e.g., "Senior Engineer Grade 7") wastes valuable space. The solution: reshape every section to answer the question "What did you personally accomplish with data?" The Core Shift: From Hierarchy to Impact In a Chinese SOE resume, it's tempting to list departments you led or teams you oversaw. In a Western senior data scientist resume, focus on the problems you defined, the algorithms you deployed, and the revenue, cost savings, or user metrics that improved. For example, instead of "Led the data analytics team of 10 people," write "Designed and deployed a demand-forecasting model that reduced inventory costs by 15% (¥12M annually)." Three Resume Sections That Require Full Rewriting Professional Summary: From 'Accomplished Engineer' to 'Data Science Leader' Start with your total years of experience, your technical stack, and the types of business problems you solve. Example: "Senior Data Scientist with 10+ years applying machine learning to supply chain and logistics. Expertise in Python, TensorFlow, and Spark. Reduced operational costs by 15-30% through predictive models deployed at [SOE name]." Work Experience: From Role Descriptions to Metric-Driven Bullets For each role, list 3-5 bullets. Every bullet should have a verb, a task, a technology (if relevant), and a quantified result. Avoid vague phrases like "responsible for." Use specific numbers: "Improved forecast accuracy from 70% to 85% by building an ensemble of ARIMA and XGBoost models." Education & Certifications: Emphasize Transferable Skills Your Chinese degree is fine, but add relevant certifications (AWS, TensorFlow, Coursera) to show adaptability. Consider a "Technical Skills" se

This is my first post here, so I'm going to use it as an introduction. I'm Usman, a software + data engineer who primarily works with data pipelines, backend systems. Not a huge fan of frontend development though. Although I do what I can, projects honestly feel incomplete without them, because at the end of the day you do have to showcase a working end to end system when you build something. I'm here after dozens of incomplete personal projects, and projects that never even got past the design phase, you know the drill. Procrastination and imposter syndrome kept stopping me from taking the next step, but I'm here now, gotta keep myself in check fr. I was scrolling through LinkedIn the past few days, and oh my god, the amount of AI-related brain rot there. Every single post written by AI, telling you how to use AI and how not to use AI. I mean I get it, yeah, the paradigm is shifting and AI is essential to development, but where are your personal anecdotes, stuff you solved, stuff you learned, the challenges you faced, how you overcame them. You know what maybe it's my fault, it's my algorithm after all. Anyway, here I am, looking to interact with like-minded engineers and learn from them. I'm also going to post regularly about my progress and what I am building, even though I have quite a bit of experience, and have built and contributed to large-scale production systems and pipelines, I'm going to start with something small, so I can stay consistent and keep myself in check. Software engineering fascinates me a lot, and there are so many domains that I wish to explore and have explored like game development, data engineering, web/app development. My significant other is graduating in a few days, and I'm thinking of making a small game for her, alongside which I'll be working on a small sales lead enrichment pipeline. Hoping to showcase my work and document it publicly, and hoping to get to know and learn from you all! Also, I'd love to know your thoughts on the am

I spent over 20 years working in industrial maintenance as a boilermaker. Most of that time was in refinery shutdowns and turnarounds—high-pressure environments where systems either hold or fail. There is no “mostly working” in that world. That experience has shaped how I approach software development. ⸻ I’m not just “learning to code.” I’m building systems. I’m currently working on transitioning into web development, but I’m not approaching it as a tutorial exercise I’m building real projects from day one—and documenting the process as I go. Not theory. Not exercises. Actual systems that are meant to run. ⸻ What I’m building right now A portfolio site that behaves like a system (kmwebdev.me) This isn’t a “personal website” in the usual sense. It’s a live system under controlled change. I treat it like industrial maintenance work: versioned updates instead of redesigns small, controlled changes only tracking what changed and why stability over aesthetics Nothing gets changed without intent. ⸻ A production-focused email framework (Skeleton Framework) Alongside the portfolio work, I’m building a separate system for HTML email development. Email is one of the most constrained environments in web development. Rendering is inconsistent, standards are partial, and modern CSS support is unreliable across many clients. So instead of fighting those constraints, I’m building a framework specifically designed around them. The focus is simple: predictable rendering in real-world email clients It’s still early, but it’s being developed with production use in mind—not experimentation. ⸻ The way I work hasn’t changed—only the tools have In industrial maintenance, you learn a few hard rules: don’t assume—verify don’t scale chaos don’t change more than you can test document everything that matters So I carry that directly into development: versioned releases (v1.0, v1.3.6, etc.) controlled incremental changes explicit documentation of limitations real-world testing across environmen

A few years into my career, I went back to a project I'd built solo about eighteen months earlier. I was proud of it at the time. It had a custom state management solution, several layers of abstraction, a utility library I'd assembled myself, and what I distinctly remember thinking of as "a robust architecture." Reading through it again, I spent twenty minutes just trying to understand why I'd built a particular module the way I had. The logic was split across four files. There were abstractions on top of abstractions. Two functions did nearly the same thing with slightly different names. A third was never called anywhere. The worst part wasn't the code itself. It was realizing that a simpler version, one I could have written in a day instead of a week, would have done exactly the same thing with a fraction of the complexity. That experience changed how I think about software development more than any course, book, or conference ever did. Writing less code, genuinely less, often requires more thinking than writing more. And the developers who figure that out early tend to produce work that holds up significantly better over time. Why More Code Doesn't Mean Better Code There's a belief that's easy to absorb early in a development career, that skill shows up in volume. More features, more files, more clever solutions. A complex system feels like proof that something serious was built here. That feeling is almost entirely wrong. More code means more surface area for bugs. Every line is a line that can break, a line that needs to be read, a line that needs to be tested, a line that a new team member has to understand before they can confidently change anything. None of those costs are trivial, and they compound. Complexity hides bugs. A simple function with one responsibility is easy to test and easy to debug. A function that does five things, or calls three other functions that each do three things, creates a web of possible failure points that's genuinely difficult t

I didn’t set out to become a systems architect. In fact, I didn’t even know that’s what I was becoming. There was no grand plan, no formal training, no moment where someone handed me a title. It happened the same way most systems failures happen: slowly, then all at once. What I did have was a habit. Whenever something broke — a workflow, a process, a piece of software, an organisation — I couldn’t leave it alone. I needed to understand why. Not the surface‑level “why,” but the structural one. The hidden one. The one nobody sees until it’s too late. Most people move on when something fails. I map it. I started noticing patterns. The same failure modes appeared everywhere: unclear ownership, mismatched incentives, brittle assumptions, invisible dependencies, and the classic “we built this fast and hoped it wouldn’t collapse.” Different domains, same architecture problems. I wasn’t trying to fix things. I was trying to understand them. But understanding inevitably leads to repair, and repair inevitably leads to design. Eventually I realised I wasn’t just analysing systems — I was architecting them. Not officially. Not ceremonially. Just… functionally. I became the person who could see the structure beneath the mess. The person who could explain why something was breaking and what would happen next. The person who could redesign the thing so it wouldn’t break again. People started asking me questions that only architects get asked. “Why is this happening?” “How do we stop it?” “What should this look like instead?” “What’s the underlying pattern here?” I didn’t have a job title for it. I didn’t need one. The work defined itself. Over time, I realised that “systems architect” was simply the most accurate description of what I was already doing. Not in the traditional enterprise sense — no UML diagrams, no formal frameworks, no ivory‑tower abstractions. More like: the person who sees the real structure beneath the chaos and can articulate it clearly enough that others fin

Table of Contents Setting a New Benchmark for Myself My Most Productive Six Months Yet 2...

From order, chaos. From courage, fear. From strength, weakness. — The 36 Stratagems, "Make a Sound...

I’ve wanted to build a text editor for a long time. Not because I thought the world needed another one — it clearly doesn’t — but because editors are one of those projects where you end up touching everything: rendering, input handling, text buffers, undo, plugins, configuration, even OS integration. It felt like the most honest way to learn how these tools actually work. So I finally did. cdin is a lightweight, keyboard-centric text editor with Vim-style modal editing. It started as a fork of lite , but over time it became something more personal. I kept the parts I liked, removed the parts I did not, and reshaped the rest to match the way I actually work. A big reason for that was my computer. I have a weak machine, and that made heavier text editors feel frustrating to use. They were often slow, laggy, or just too much for what I needed. That is how I discovered lite in the first place. It was close to what I wanted, but not quite there. So I forked it, renamed it to cdin, and started making it mine. That meant more than just small tweaks. I removed features I did not need, changed the things that felt awkward, moved from SDL2 to SDL3, and rewired a lot of the project structure along the way. The result is cdin: a small editor built around speed, simplicity, and hackability. The name itself is simple too. cdin means “CODE in”. The code is split between C and Lua. The C side handles the window, renderer, and SDL bindings. Everything else — behavior, plugins, keybindings, config — is loaded in Lua at runtime. That keeps the editor flexible without making it feel heavy. If you want to explore the project, here are the main docs: Overview · Getting Started · Building from Source · Configuration · Vim Keybindings · Plugins · Command Reference There is still a lot I want to improve, but cdin already feels like something that belongs to me in a way no other editor ever did. If you check it out, please leave a star, fork it, or send an Issue or PR if you find a bug or wa

I've noticed something about myself. It's become much harder to get things done. I see less movement compared to my previous self. And sometimes, when I see people get so much done, tasks, projects, anything, I wonder why I can't make progress like that. Now I'm not comparing myself to Elon Musk here, I'm just wondering if I'm doing my best. For the longest time, I've wanted to build a portfolio website. But for some reason or another, I never actually ended up making it, or should I say, starting it. Whenever I had a free block of time, I wouldn't know where to start. I also have this side project I've been wanting to work on. I started it, then never made any more progress beyond the initial feasibility analysis. Why did I never allocate time to either? The Overthinking Starts Early I wanted the portfolio website to be really good. I wanted cool additions, beyond the usual "about me" and "projects" sections, I wanted things like "songs I'm obsessed with right now" and "last night I slept at." I was also looking if my fitbit has an API to show my live heart-rate on my portfolio (why would someone do that?). I was obsessed with the features, and with using the right tech to make it as efficient as possible. What stack should I even use for a portfolio? Same story with this very blog. Before writing a single word, I was wondering what stack to use. I looked into a ton of existing blogs for inspiration, how do I track views, what about comments, how do I stop a DDoS from flooding my DB if I'm storing comments, should I require auth just to leave a comment, should I support font and background color changes, themes, what's the best tool to do all of that? I've noticed this pattern with almost everything I do. I'm so obsessed with doing things right on the first attempt that I never actually make the first attempt, because "doing it right" is just too demanding. Or a related trap, when I want to do something perfectly , I discover prerequisites, and those prerequisites

There is a fascinating, quiet tension happening in the software engineering community right now. If you listen closely to late-night developer chats, team syncs, or tech forums, you will notice that our industry has rapidly split into two distinct schools of thought regarding the rise of AI coding tools like Cursor, Claude Code, and Copilot. On one side, you have the Traditional Developers. They argue that software engineering is a disciplined art form that cannot be replaced by text prompts. To them, unchecked AI coding is a recipe for buggy, unreadable spaghetti code, creating a technical debt nightmare for the future. On the other side, you have the Vibe Coders. This is a fast-moving generation of builders, both technical and non-technical, who believe in shipping fast, prompting quickly, and adjusting on the fly. They do not see a need to obsess over syntax when the AI can translate their intent into a working application in minutes. The reality is that both sides are entirely right. If we stop arguing over who is ruling the current meta and actually look at the core truths each camp holds, we can see exactly where the future of software development is heading. 1. The Traditional Developer is Right: Guardrails Matter The traditional development camp is fundamentally right about structure. Building a beautifully designed UI that works on a surface level is vastly different from building an enterprise-ready, scalable architecture. When you prompt an AI to build a feature, its primary objective is to satisfy the literal words in your core prompt. This is the "as long as it works" mentality. Unless you are practicing strict, spec-driven development and explicitly dictating your architectural doctrines, security protocols, and API patterns, the AI will make assumptions for you. Historically, those assumptions are optimized for speed and not long-term stability. Without deep technical oversight to catch anti-patterns, edge cases, and hidden security flaws, fast-shippe

There is a ghost haunting the tech industry right now, and nobody wants to talk about it: The Junior Developer role is disappearing. With tools like GitHub Copilot, ChatGPT, and advanced coding agents becoming standard issue in every IDE, senior developers are suddenly 10x more productive. They no longer need a junior developer to write boilerplate code, write unit tests, or scaffold out basic UI components. The AI does it instantly. So, if you are a junior developer, or aspiring to break into tech, how do you survive? 1. Stop Memorizing Syntax, Start Thinking Architecturally AI is incredible at writing syntax, but it is terrible at system design. If your only skill is writing a for loop in React, you are competing with an AI that works for $20/month. Instead, focus on understanding how systems fit together. Learn about cloud architecture, database indexing, and distributed systems. The AI can write the function, but you have to know where that function lives and how it scales. 2. Become a "Domain Expert" Developer AI doesn't understand the nuanced business logic of the healthcare industry, or the strict compliance regulations of fintech. If you combine coding skills with deep industry knowledge, you become irreplaceable. 3. Embrace the Tools (Be the Orchestrator) Don't fight the AI. Master it. The developers who thrive in the next decade will be the ones who treat AI agents like a team of junior developers reporting to them. Learn how to craft the perfect prompts, how to use Retrieval-Augmented Generation (RAG), and how to orchestrate multiple LLMs to build complex applications. The barrier to entry for writing code has dropped to zero. But the barrier to entry for building valuable software remains exactly the same. Are you terrified of AI replacing you, or are you using it to level up?

TL;DR: I set up a Claude Code skill that checks in with me about my workday, asks follow-up questions, and saves a structured markdown file I can use as promotion evidence. Here's why it works, and how to build one in about five minutes. May 6th On May 6th I had an energy level of 2 out of 5. I got my Claude Certified Architect exam score back that day: 717 out of 1000. I needed 720. I missed it by three points. Four lines down in the same entry, my manager had told me: "your leadership is being felt around Artium. You're making a good impact." Here's the thing about that day: the bad number is vivid and self-evident. 717. Three points short. That number was going to live in my head rent-free for weeks. But the recognition? That quietly evaporates. Left to memory, May 6th is the day I failed the exam by three points. On the page, it's also the day my manager told me my leadership was landing across the company. The entry keeps the thing I'd lose otherwise. The Problem With Memory I've been bad at this for years. At performance review time, I'd stare at a blank document trying to remember what I'd actually done. I'd come up with four things instead of forty. My manager would advocate for me based on what she happened to see, which was never the full picture. The thing is, I did good work. I just didn't capture it. A few years ago I tried to solve this with Google Forms , a structured form I'd fill out at the end of each day that fed into a spreadsheet. It worked, kind of. The data was there, but it felt like homework. The form didn't ask follow-up questions. It didn't notice when I was being vague. I had to go somewhere specific to fill it out. And when review time came, I had to go back somewhere else to compile everything, figure out what mattered, and assemble it into something coherent. The friction wasn't just the daily entry. It was the whole chain: capture, retrieve, synthesize, present. I was on my own at every step. So I built something better. What I Built