Blog

  • The Day I Became a Public Servant

    Part 3 of “Before I Go”, a career retrospective.


    Sixteen years. That’s how long I worked for LA County before I understood what it actually meant to serve the public.

    I didn’t arrive at that understanding in a meeting or through a training program. I arrived at it by walking into a lobby.

    It was an ordinary morning at the Medical Examiner-Coroner’s Office, the kind where you come in, get your coffee, and start working through your list. Except when I walked through the entrance that day, there were about a dozen people clustered in the lobby, holding each other up. Some were crying. Others stood quietly with that particular stillness that grief produces in people who have run out of words. At the counter, one of the staff was at the computer looking up information, while an investigator stood nearby explaining the process of what happens next, what the family needs to do, and what the office can tell them and when.

    I had seen public-facing service before. I just had never seen it look like that.

    The sixteen years before the Coroner were a good career. A real career, even. I moved through Internal Services, the Superior Court, the Public Defender’s Office, and ISAB offices in Cerritos. I built things, solved problems, and got promoted. But those assignments shared a common feature: I worked in buildings where the public didn’t come. Internal Services was exactly what the name suggests, a support organization that served other county departments, who then served the public. The connection to the people LA County actually existed to help was real, but it was indirect, abstract, and easy to lose sight of on a busy Tuesday.

    I understood, intellectually, that the systems I maintained mattered to someone. I just rarely saw who that someone was.

    There’s a particular kind of drift that happens when you work that way for long enough. It isn’t negligence or indifference, just distance. You optimize for the system in front of you because that’s what you can see and measure. The person whose life is actually affected by whether the system works becomes theoretical. Someone you’d describe in a requirements document as a user or a stakeholder, but never actually meet.

    The Coroner fixed that for me.

    Getting the job required passing a biology tour first. The department wanted to make sure candidates could handle the environment before hiring anyone into it. The work was, to put it plainly, icky sometimes. You’d sit in meetings where the conversation moved casually from budget line items to bone saws to the particular challenges of cases that had been left too long. I wasn’t entirely sure I could handle it before I walked in. Fortunately, the person running the tour kept things moving and we didn’t dwell on any one thing for too long.

    I took the job but I stopped eating red meat for about a year.

    What I didn’t anticipate was how much the environment would change how I thought about the work. Families came to that lobby every day. They came because someone they loved had died, often suddenly, often violently, and the Coroner’s Office was the first place they had to go to begin understanding what happened. They came with questions, they came needing information that was hard to give, and they came in the middle of the worst days of their lives.

    The IT systems either worked or they didn’t, and now I could see exactly what that meant.

    For the first time in my career, I could trace a direct line from the work I did to the experience of a specific person in a specific kind of pain. When the case management system was slow, someone at that counter was slower to answer a question. When a database was unavailable, a family waited longer for information they had driven across the County to get. The abstraction I had been living inside for sixteen years was simply gone, and the work carried a weight it hadn’t before.

    I’ve thought a lot since then about what those first sixteen years cost me in terms of perspective, and what they cost the people I was serving, indirectly, without knowing it.

    I don’t think bad work gets done in government IT because people don’t care. I think it gets done because distance makes it easy to optimize for the wrong things. When you can’t see the person at the end of the chain, you optimize for the system. You solve the technical problem in front of you and call it done. You measure success by uptime and ticket closure rates and project milestones, because those are the things you can see.

    The Coroner taught me to measure by something harder to quantify: whether the person in the lobby got what they needed.

    I’ve argued ever since that every County IT employee should spend time in a public-facing role. Not a one-day field trip, but real time, long enough to feel the connection between what you build and who it affects. I held that view before hybrid work became a policy question, and I hold it more strongly now. I understand the arguments for flexibility and I support them for the right reasons. But something is lost when the people building and maintaining public systems never have to look at the people those systems are supposed to serve.

    The lobby at the Coroner’s Office was not always a comfortable place to be, but It was, in a way I’m still grateful for, exactly the place I needed to be.

  • The Friction is the Feature

    Part 2 of “Before I Go”, a career retrospective


    I’ve spent 35 years inside government IT, and in that time I’ve watched the same cycle repeat more times than I can count. Someone discovers that government IT is slow. They write about it, speak about it at conferences, and build a startup to fix it. Then government IT remains slow, and the cycle starts again. What those observers usually miss is that the slowness isn’t the problem. In most cases, it’s the point.

    The structures that govern how government IT operates exist for reasons that predate your frustration with them. Procurement rules exist because public money was abused. Civil service requirements exist because hiring was once done as political patronage. Oversight layers exist because, without them, accountability disappears. These aren’t bureaucratic accidents. They’re responses to real problems, encoded into policy over decades.

    When you’re waiting 12 to 18 months to hire a single position, you’re not experiencing organizational incompetence. You’re experiencing the full weight of that history.

    Here’s what that process actually looks like from the inside. You identify the need for additional staffing early in the year. A budget request goes in during October or November. After budget hearings and multiple reviews, if approved, it clears the Board of Supervisors in late April. The hiring process can’t start until the new fiscal year begins in July. Then the civil service process begins. The job listing is posted; applications are accepted; civil service exams are scheduled, taken, and scored; candidates are ranked; and finally a candidate list is certified and promulgated. That list is only valid for one year. Candidates are contacted, interviews are scheduled and conducted, and finally a selection is made pending a background check that can take three months on its own. If top candidates accept other jobs while you’re waiting, the list shrinks. If it expires before you hire, you start over.

    The best case is 12 to 18 months from request to first day. That is the optimistic scenario.

    I’ve had this conversation with department managers, executives, and people who were genuinely just trying to get someone hired. The reaction is almost always the same. They hear the explanation, they nod, and somewhere behind their eyes I can see them deciding that I’m either making excuses or describing a problem I should fix. They accept the answer. I’m not sure they ever fully believe it.

    After three and a half decades, what I’ve learned is that you can’t fight the structure. You can learn its shape and plan around it. Start the budget request before you think you need to. Anticipate the exam cycle. Know which steps have flexibility and which ones don’t. The people who get frustrated and try to find shortcuts usually end up taking longer than the people who work the process. What seems like the easy way is usually the hard way. The hard way is usually the only way.

    I’ve come to think of this as steering into the curve. It’s a concept loosely borrowed from physics. When space curves, the straight path isn’t the one that looks straight to you. It’s the one that follows the curvature. You don’t fight the bend. You work with it, let the structure do what it’s designed to do, and get where you’re going by following the geometry rather than ignoring it.

    There’s also something worth saying about what the CIO of a government department actually controls, because the assumption from the outside is usually everything with a power cord. The reality in LA County is that the mainframe, the network, the firewall, and the servers are all managed by central county departments. When something goes wrong with the network, I’m making a phone call, not a configuration change. When a security policy conflicts with a business need, I’m navigating an interagency conversation, not issuing a directive.

    LA County employs roughly 110,000 people. The District Attorney’s Office, where I serve as CIO, has about 2,000. We are one department inside a very large county government, operating under shared infrastructure and shared governance. The idea that an executive at the department level can simply decide to implement a technology and have it done, without procurement, without central IT involvement, without security review, runs into reality quickly. The County is not a small independent office. It is a large, complex, interdependent system, and IT reflects that.

    I think about this when I look at how the County is approaching artificial intelligence. A tool that a private company might adopt in a week requires a county AI governing board review before any department can authorize it. That once struck people as excessive caution. I’ve come around to thinking it’s exactly right, at least for AI. The technology is moving faster than anyone’s full understanding of its implications, particularly in criminal justice contexts where the consequences of getting it wrong are serious. The same structural slowness that frustrated me for decades when I was trying to hire a programmer is, in this case, doing exactly what it was designed to do, which is slow down something moving too fast for proper consideration.

    The hardest part of a career in government IT isn’t the bureaucracy itself. It’s the gap between what you imagined you could accomplish and what the system actually allows. I had ideas about how I wanted to improve things, move the organization forward, make the work better for the people doing it. Some of those ideas happened. Many didn’t, or happened so slowly and incrementally that it’s hard to feel the distance traveled. You look back across 35 years and wonder whether you moved the needle enough.

    I don’t have a clean answer to that. What I know is that the people who fared worst in this environment were the ones who spent their energy fighting the structure rather than learning it. The ones who fared best understood early that working within constraints isn’t the same as accepting defeat. It’s a different kind of skill, less visible and less celebrated than the technical work, and in my experience more necessary than almost anything else government IT asks of you.

    The curve is real. You can’t make it straight. What you can do is learn to steer.

  • Before the County, There Was Douglas Aircraft

    Part 1 of “Before I Go”, a career retrospective.

    In the summer of 1986, I walked into a building in Industry, California that looked nothing like a college campus. There was no quad or clock tower, only an office park with classrooms. I was 18, just out of high school, and almost certainly the youngest person in the room.

    Most of my classmates at DeVry University were older and embarking on a second career in technology. They had work history, rent, families. I had a scholarship that covered tuition and fees, a commute from Norwalk, and a conviction that I wanted to work with computers that I’d been carrying since I first heard Majel Barrett’s voice coming out of the Enterprise computer.

    The scholarship wasn’t automatic. I applied, submitted an essay along with my SAT score, and DeVry eventually announced I was the winner. My high school wasn’t pleased. Their preference was a traditional four-year university, and a for-profit technical school didn’t fit the picture they had in mind. I understood the concern, but I wasn’t interested in a picture. I wanted to write code.

    DeVry’s structure was unusual. Every student in the Computer Information Systems program followed the same fixed schedule. We stayed in the same room all day; the professors rotated in. The curriculum covered mainframe tools like COBOL, CICS, IMS, and JCL, alongside courses in financial accounting, business writing, psychology, economics, public speaking, and a senior project. Faculty were required to have real-world industry experience, not just academic credentials. That distinction mattered more than I understood at the time.

    My first trimester brought Professor Chang, who taught Pascal. He was brilliant and difficult to follow, and he taught by making you figure things out rather than by giving you answers. His accent was strong enough that the whole class struggled to keep up, which led to one of the more memorable moments of that first trimester. He was explaining bit manipulation — how a byte has eight bits, and how a byte can be divided into two halves. He kept referring to each half by its technical name, but what came out of his mouth, in that accent, sounded unmistakably like ‘nipple.’ Nobody said anything for a while. Finally, one of the more outspoken students asked him to write the word on the board so we could make sure we had the spelling right. He wrote “nybble.” The room collectively exhaled. He noticed our reaction, asked what he had been saying, and when we told him, he spent a few moments practicing the correct pronunciation — nibble, nibble, nibble — before it dawned on him what we had been hearing for the past several minutes. He was genuinely embarrassed. We thought he was great. What I took from his approach, beyond that moment, was a habit of mind: when you hit a wall, your job is to reason through it, not wait for someone to open a door.

    I completed eight trimesters in roughly three years and graduated Summa Cum Laude. The practical curriculum turned out to be a significant advantage that I didn’t fully appreciate until I hit the workforce.

    DeVry’s placement office found me my first job. Douglas Aircraft in Long Beach hired me as an Engineer in Quality Systems at $28,000 a year paid weekly. I chose it over other offers because the commute from Norwalk to Long Beach didn’t require freeway driving. That’s the kind of logic that makes perfect sense at 22.

    Douglas ran on an IBM VM/SP mainframe, and the setup was unlike anything I’d encountered at DeVry. Each user got their own virtual machine running CMS on IBM’s VM/SP OS, which functioned as a personal workstation at a time when personal workstations weren’t yet a real concept. We used REXX for scripting, ISPF panels for screens, SQL/DS for data management, and GML/SCRIPT for documentation. The company also ran PROFS, IBM’s office system, which handled corporate email, messaging, and calendaring across the organization. It was a complete, production-grade technology stack that predated the tools most people associate with that era by close to a decade.

    My work was building administrative database applications that supported the quality assurance function. One of these tracked airworthiness directives which are FAA safety mandates that manufacturers were required to compile and deliver with each aircraft. Without a complete set, the plane couldn’t be handed over to the customer. If the system failed, a finished aircraft sat on the tarmac. That’s the weight the work carried.

    Every morning I walked through the manufacturing floor to get to my desk. Twenty-five minutes past MD-80s and MD-11s. The physical scale of a commercial aircraft when you’re standing next to one is nothing like seeing it from an airport gate. I watched landing gear tests on planes lifted off the floor on hydraulic jacks. The MD-11 tail stabilizers were too large for the hangar and had to be installed outside. I wore Douglas t-shirts on flights and got attention from flight attendants who wanted to know what I did for the company. One of those conversations led to a date that ended in complete disaster, but that’s a separate story.

    Then the layoff came.

    I knew it was coming. That didn’t make it better. My manager arrived with an envelope, worked through a checklist, walked me to the door, and took my badge. Under California EDD rules, a layoff of that scale required six weeks’ notice, but they released me from duties after two weeks with pay continuing for the remainder. I called DeVry’s placement office. The same office that found me Douglas now found me LA County.

    But first, a brief detour. While waiting for the County offer to come through, I took a job at a small software distribution company in Culver City. The owner had a vision of building the Nordstrom’s of software. It was twelve people, a long commute, rigid lunch rules, and an expectation that you’d stay late without asking questions. I had already interviewed at the County during my first week there. When the County offer finally arrived in late September, I gave my notice and served two of the best weeks of my working life. I came in when I felt like it, left when I was done, and genuinely did not care about much of anything. I didn’t understand at the time how precisely that feeling would echo something I’d feel 36 years later, but that’s getting ahead of the story.

    I arrived at LA County’s Internal Services Department as an Assistant Programmer Analyst in 1990. I was part of a large training cohort, about 30 to 40 people in my group, with three groups total recruited from outside. Most of them were fresh from Cal State schools, trained in UNIX and theoretical computer science. I already knew COBOL, JCL, and IMS cold. Much of the training was redundant. The pay was $34,000 a year, more than Douglas. The commute from Norwalk to Downey was short.

    What I found at my desk was a different story.

    The County ran IBM 3270 terminals, massive machines with heavy keyboards. At Douglas I had been working in a virtual machine environment that gave every user the computing experience of a personal workstation. The County 3270 was a significant step backwards from everything I’d just left, and the difference hit me the first week.

    The colleague in the adjacent cubicle had arrived in the first training cohort, a few months before me. Her terminal happened to be located on the desk I’d been assigned which, when you think about it, made it legitimately hers before I ever showed up. She would come to my desk to use it, and I’d wander the building looking for an open machine, or sit in a shared terminal room with about 15 workstations and most of the department competing for time on them.

    Nobody at the County seemed to find this surprising.

    There’s a version of this story where I’m the hero of it — the hotshot who showed up knowing more than his colleagues and had to endure conditions unworthy of his abilities. That’s not the story. The terminal situation was just a symptom of something structural. Government IT in 1990 was constrained by budget, procurement timelines, and a set of priorities that had nothing to do with giving any individual employee the best tools. I would spend the next three decades learning how those constraints work, where they come from, and why they’re harder to change than they look.

    That’s the subject of a different article.

    The question I keep returning to about those early years is simpler: what do you do with an advantage you didn’t ask for? DeVry gave me a running start. Douglas confirmed it was real. The County reset the clock, at least tactically.

    What you do, it turns out, is show up anyway. You learn the environment you’re actually in, not the one you were expecting. And you wait for the work to start meaning something.

    For me, that wait took sixteen years. But that’s also a different article.

  • What Really Happened. An Honest Review.

    What Really Happened. An Honest Review.

    Originally published on LinkedIn – Read the original post

    The first two articles in this series were about ideas and feelings. This one is about what happened, the workflow, the failures, the moments where everything went sideways, and the honest verdict on whether any of this was worth it.

    It was. But let me tell you what it looked like.

    How the workflow evolved

    I didn’t start with a sophisticated setup. I started by copying and pasting. Early sessions with ChatGPT involved generating code in a desktop chat window and manually dropping it into Xcode. No integration, no continuity, just a lot of switching between windows and hoping nothing broke.

    The toolset evolved from there. AI tools came directly into Xcode, which helped. Eventually I settled into Claude Desktop alongside Claude in Xcode and added GitHub for project tracking. My current setup might look strange to a traditional developer, but it works.

    Here’s how it runs: I have two Claude sessions going at the same time. One is the architect. One is the programmer. They serve completely different purposes and keeping them separate is one of the most important things I figured out.

    The two-Claude system

    The architect session lives in Claude Desktop. This is where strategy happens. We discuss goals, direction, what I want the app to do and equally important, what I don’t want it to do. When I find a bug in testing, I bring it here first. When something isn’t working the way Apple recommends, I ask here. Recently I had issues with notifications not behaving correctly and I asked Claude Desktop: is this the right approach, is this current, is this how Apple wants developers to approach it? That kind of architectural review is invaluable.

    Claude Desktop also tracks everything in GitHub and, critically, generates the prompt that goes to the programmer session. It doesn’t just identify the problem. It writes the exact instructions needed to fix it, accounting for the overall project context, the architecture decisions we’ve already made, and the approach we want to take.

    The programmer session lives in Claude within Xcode. It receives that prompt and executes it. It touches the code. It makes the changes. It doesn’t need to know the whole project history because the architect has already distilled everything it needs into a precise set of instructions.

    When I’ve tested and everything works, I report back to the architect, the GitHub issue gets closed, and we move to the next one.

    It sounds complicated written out. In practice it feels like having a project manager and a developer on call at the same time.

    What went wrong

    Here’s the honest part.

    The programmer Claude occasionally goes off script. You describe a problem, you know roughly what the fix should be, and instead of making the targeted change you asked for, Claude starts making broader modifications, touching things that didn’t need touching, solving problems you didn’t have. You must learn to recognize when this is happening and pull it back. Clear, specific prompts help. The more precisely the architect defines the task, the less room the programmer has to improvise in unhelpful directions.

    The bigger failure mode was a single incident that tested everything I had.

    I had just finished a batch of changes. Ran the app in the simulator, everything looked good. Exited, decided I wanted to check something, reloaded. The app hung on the launch screen. Nothing. Just the launch screen sitting there.

    I started troubleshooting with Claude. We added debug lines, console print statements, trying to see what was happening. Nothing showed up in the logs. It was as if the app wasn’t running at all, just displaying a static image of its own launch screen.

    So, I rolled back to the previous commit. Same problem. Rolled back again. Still broken. I kept going back through the commit history, undoing hours of work, and nothing changed. Claude suggested approaches, I tried them. Reset the simulator. Restarted Xcode. Nothing worked.

    I’ll be honest: I was rattled. This is the part of the experience that’s genuinely hard when you don’t have deep technical expertise. When something breaks in a way you don’t understand and the tools that are supposed to help you can’t find the answer, it’s easy to feel lost. I felt lost.

    And then I did what 36 years of problem-solving experience taught me to do. I stopped. I calmed down. I stopped following Claude’s suggestions and started thinking systematically on my own.

    Eventually I found it. Xcode had updated, but the simulator environment hadn’t finished downloading the corresponding update. The app wasn’t broken. The simulator was incomplete. There was a download quietly happening in the background with no clear indication that this was the issue. Once it finished, everything worked. I reapplied all the rolled-back code and the app ran perfectly.

    Claude didn’t solve that problem. I did. And that matters.

    Before a single line of code

    If I were starting over today, the first thing I’d tell someone is this: before you ask AI to write anything, have a long conversation about what you’re building.

    Not a requirements document. A conversation. Talk through the goals. Talk through what you want and what you don’t want. Ask what the platform is capable of. Get a reality check on your ideas before you’ve invested hours building in the wrong direction. Ask Claude to push back on your assumptions.

    This is the step most people skip and the one that pays the biggest dividends. The clearer your vision going in, the more useful every interaction becomes after that.

    Here’s what that looks like in practice. Before writing a line of code, work with Claude to produce actual documents: an architecture document, a design document, a list of decisions you’ve made and why. These become living references that both you and Claude can return to throughout the project. They keep the work grounded when things get complicated, and they give Claude the context it needs to make good decisions rather than just technically correct ones.

    Then set up a Claude Project for your app and have all your development conversations inside it. Add those architecture and design documents to the project so Claude always has them available. Write project instructions that keep every conversation focused on your goals, your constraints, and your decisions. This sounds like overhead. It isn’t. It’s the scaffolding that keeps the whole thing from drifting.

    GitHub plays a similar role. Once you have your plan and your architecture, you need a place to track every task, every decision, every bug, every next step. GitHub issues give you that. But take it a step further: connect Claude to your GitHub directly so it can open issues, update them, and close them out without you having to do it manually. Claude becomes the project manager, not just the programmer. Nothing gets lost, nothing gets forgotten, and you always know exactly where things stand.

    The other connection worth making: enable the Filesystem connector in Claude Desktop. This lets your architect Claude read your project files before telling the programmer Claude what changes to make. Instead of working from memory or your description of the code, it can review what’s there. That difference matters. Instructions based on the real current state of your files are more precise, less likely to conflict with something else, and far less likely to send the programmer off in the wrong direction.

    The other thing I’d say: expect your workflow to change. Mine looked nothing like my current setup six months ago and I expect it to keep evolving. The tools are moving fast. Stay curious and stay flexible.

    The honest verdict

    This was an experiment at the beginning. I genuinely didn’t know if someone with my background, deep in IT but decades removed from hands-on development, could build a real, published iOS app using AI as a coding partner.

    The answer is yes. Unambiguously yes.

    And I’m not done. I have a pipeline of app ideas and the confidence now to build each of them. The experiment became a method. The method became a practice. And that practice is shaping what I plan to do in retirement.

    The tools aren’t perfect. The workflow takes time to develop. There will be moments where you feel lost and the AI can’t find the answer either. But if you bring domain expertise, clear vision, and the patience to manage the process like the leader you already are, you can build things you never thought you could build.

    I know because I did it. And I’m already doing it again.


    This article is Part 3 of a three-part series, Building with Claude. Read Part 1 and Part 2.

  • A CIO Who Learned to Code Again

    A CIO Who Learned to Code Again

    Originally published on LinkedIn – Read the original post

    This one is harder to write than Part 1. Part 1 was about ideas. This one is about me.

    I want to tell you how the Work Balance App actually started, because the truth is a little embarrassing and kind of funny.

    My staff are expected to be in the office two days per week, one of which must be Wednesday. Simple rule. Except month after month I was seeing timecards that got it wrong. People would structure their week around their preferred telework days and lose track of the actual requirement. On weeks with a Monday holiday, someone would extend the long weekend by taking Tuesday and Wednesday off, then telework Thursday and Friday because those were their normal remote days. No office days that week. At all.

    I explained it. I explained it again. More times than I care to count. And then one day, instead of sending yet another email, I thought: I should build an app for this.

    Which, looking back, is completely absurd. No app was needed. A calendar and some basic math would have solved the problem. But frustration has a way of channeling itself into strange places, and for me it channeled itself into learning iOS development. It was mostly an inside joke with myself. I never told my team. I don’t expect anyone on my staff to ever use it. And honestly, part of what kept me going was the private laugh of knowing I was building something this elaborate to solve something this simple.

    The experiment nobody knew about

    I started with ChatGPT. We’d begin a session, map out a list of things to build, and start working through them. It went fine at first. But as conversations grew longer, something would shift. ChatGPT would start to lose the thread. I’d ask about the next item on our list and it would seem to have forgotten what we were doing. I’d ask it to add a standard comment header to every file in the project, it would produce a list, start working through it, and then halfway through begin losing track of which files had already been done. It would confidently suggest reopening files it had already processed. Over and over I’d have to redirect it, remind it, restart.

    The bigger problem was that I started losing track of the overall project goals myself. There was no good way to maintain continuity across sessions. Every conversation was essentially starting fresh.

    Then I switched to Claude.

    What Claude does differently

    The difference that mattered most wasn’t immediately obvious. It wasn’t the quality of a single response or the elegance of a particular piece of code, though both were better. It was how Claude managed the project over time.

    Claude uses GitHub to track issues, progress, and next steps, referencing it continuously throughout our work together. Whether that was Claude’s idea or mine I honestly can’t remember, but it never occurred to me when I was working with ChatGPT. The result is that nothing gets lost across sessions.

    But what really stood out was something more subtle. Claude seems to understand that its own memory has limits. It periodically and deliberately compresses and summarizes our conversations, keeping the most important context front and center so the overall project goals don’t get buried under the details of whatever we’re working on in the moment. It knows what it can’t hold onto, so it writes things down. ChatGPT never did that. It would just quietly lose the thread and keep going as if nothing had changed.

    That kind of self-aware working style turns out to matter enormously when you’re building something real across many sessions. You need a collaborator who manages the project, not just the current task.

    The moment it became real

    Version 1.0 shipped. And I was surprised by how proud I felt.

    I didn’t expect that. I’d built the thing, I’d watched it come together piece by piece, but there was something different about seeing it actually running on my phone, doing exactly what I’d imagined it would do, solving the exact problem that had frustrated me into building it in the first place.

    And then I thought: I’m not done. I already have a roadmap mapped out through version 1.6, maybe 1.7. The Week Planner feature that started all of this is just the beginning. The app isn’t finished. I’m not finished.

    What this really gave me

    I got into technology because it felt like magic. I grew up watching Star Trek, marveling at what the library computer could do, the way it just knew things, understood questions, responded almost like a person. That sense of wonder is what pulled me toward IT in the first place. Computers were going to change everything, and I wanted to be part of that.

    Thirty-six years later, after budgets and procurement cycles and compliance audits and staff meetings, it’s easy to forget that feeling. Public service has a way of grinding the wonder out of things. The work matters deeply, but the spark that got you there can quietly disappear without you noticing.

    Building this app brought it back.

    I have a list of app ideas. Several of them. I’ve been adding to it since the Work Balance App launched, and I’m already deep into my second project. After 36 years in IT, most of them in leadership roles where my job was to enable other people to build things, I am building things myself again.

    More than that: I’m excited about what comes next. Genuinely, specifically excited. Not the general optimism you talk yourself into when a big life transition is approaching, but the particular kind of excitement that comes from having a list of things you actually want to accomplish and knowing you have the tools to accomplish them.

    I’m approaching retirement at the end of 2026. I’m ready for it. But the Work Balance App is a big part of why I’m not just ready to leave something behind. I’m ready to run toward what’s next.

    I’m passionate about something again. It took an app about work scheduling to remind me what that feels like.


    This article is Part 2 of a three-part series, Building with Claude. Read Part 1 and Part 3

  • The AI Co-Developer Is Here. Are You Ready?

    The AI Co-Developer Is Here. Are You Ready?

    Originally published on LinkedIn – Read the original post

    I built an iOS app. Me, a CIO with almost 36 years in IT, a full-time job running technology for one of the largest prosecutorial offices in the country, and a development background that hadn’t been seriously exercised in decades. I built a working, functional iOS app. And it changed how I think about the future of technology leadership.

    It started simply enough. LA County has complex telework policies, tracking work modes, RDOs, PTO, and holidays, and I needed something to manage it that didn’t exist. So I decided to build it myself. What started as solving a personal problem became something more: a deliberate experiment in whether a non-developer could ship real software in the age of AI. Spoiler: you can.

    The moment everything shifted

    I came into this with some relevant history, though not recent history. Early in my career I wrote COBOL, batch and CICS, working with IMS databases and flat files. I programmed in Easel back when 4GLs were a genuinely new idea, and dabbled in dBase along the way. But that was a long time ago. The languages, frameworks, and tools that developers use today barely resemble what I grew up on. So while I understood the concepts, I was in no way a practicing developer walking into this project.

    And yet I still didn’t expect what happened: I stopped caring about learning Swift almost entirely. Not because it was too hard, but because I didn’t need to. Somewhere along the way, the moment I saw the app actually running on my phone doing exactly what I’d envisioned, something clicked. After 36 years in IT, I finally didn’t need to know the implementation details. I needed to know what I wanted. That’s a fundamentally different relationship with technology than even experienced technologists are used to.

    Claude is a junior-to-intermediate developer

    Here’s the most useful mental model I’ve found: Claude is like a talented junior-to-intermediate programmer. Technically capable, fast, eager. But without strong direction, vision, and leadership, the output will drift. It will solve the wrong problem elegantly. It will make technically correct decisions that miss the point entirely.

    What I brought to this project wasn’t code. It was everything else: deep domain knowledge of the problem, judgment about what users actually needed, the vision of what the app should feel and behave like, and the ability to recognize when Claude was wrong. That last one matters more than people realize. AI-generated code isn’t always right. Knowing when to push back, redirect, or scrap and restart requires exactly the kind of experience and judgment that technology leaders spend careers developing.

    In other words: the skills that make a great CIO also make a great AI development partner.

    The skill you didn’t know you already had

    Here’s what surprised me most: working with Claude felt familiar. Not because I remembered my COBOL days, but because it’s exactly how I’ve operated as a CIO for years. I don’t know everything about security, or operations, or application development. Nobody does. There’s simply too much IT to know everything. What I do know is how to lead people who have that expertise. How to set a clear direction. How to ask the right questions, evaluate the answers, and make decisions with incomplete information.

    That’s the job. And it turns out, it’s also exactly the skill set you need to be effective with AI-assisted development. If you’ve spent years learning to lead without knowing every detail, trusting your team while still holding them accountable to the vision, you’re already prepared for this. You just haven’t tried it yet.

    What this means for your organization

    Every technology leader should understand this shift from experience, not just from briefings. Because your developers are already using these tools. Your product teams will be soon. And the decisions that follow, how to structure teams, where to invest, what skills to hire for, are leadership decisions, not technical ones.

    My honest take on what’s coming for development teams: developers who are open-minded and willing to adapt will be fine, more than fine. The role is evolving, not disappearing. But you need less of a pure coder and more of a developer who understands programming concepts well enough to direct AI effectively, evaluate its output critically, and bring genuine design thinking to the table.

    Developers who want to keep their heads down and write code the same way they always have? They should be paying attention.

    The bigger shift

    The most profound change isn’t that AI can write code. It’s that domain expertise is now a development superpower. The person who understands a problem most deeply, who knows the edge cases, the user needs, the institutional context, is now the most valuable person in the room when building a solution.

    That used to be the business analyst handing requirements to a developer. Now it can be the person who builds it.

    I’m not suggesting every executive should ship an app. But I am suggesting that if you lead a technology organization and you haven’t experienced AI-assisted development firsthand, you’re making decisions about a world you haven’t seen yet.

    Go build something. Even something small. The clarity it gives you is worth more than any briefing document I’ve ever read.


    This article is Part 1 of a three-part series, Building with Claude. Read Part 2 and Part 3.