AI Ethics at The Crossroads: How Engineers Are Working to Not Make the Wrong Turn

Explore how engineering teams transform abstract AI ethics into working code and systems, from basic safety controls to sophisticated value alignment. After some time off from writing during Australian summer in the South Hemisphere, I am back to the keyboard!

Engineers Transform AI Ethics from Code to Reality

The debate around AI ethics often centers on abstract philosophical principles or futuristic scenarios. Yet in engineering departments worldwide, teams are already writing the code that determines how AI systems make ethical decisions. As someone who's built analytics departments and implemented AI systems, I've seen firsthand how theoretical ethics becomes practical reality.

In this edition, I’m here to show you how we take philosophical ethics—like virtue ethics which I often refer to—and turn it into code that shapes the algorithms running your life. If you're not a tech person, I get it. You might be tempted to tune out. But stay with me.

Back in the 15 October 2023 edition of this publication, Between the Lines of Code, I broke down the five fundamental pillars of ethical AI. Today, I'm showing you how those principles become actual lines of code. This isn’t just technical jargon—this is about the foundation of the systems that are quietly, but powerfully, shaping your life.

Why should you care? Because this code already impacts your banking, healthcare, job applications, performance reviews, government decisions, military weapons, art, music, education—every corner of your life is being touched, or soon will be. Algorithms will decide if you get a mortgage, if your kids are accepted into school, and even if your emails pass the scrutiny of AI tools. At work, people are running what you produce through AI, and you're likely doing the same to their work. Tax agencies use AI to comb through your filings, cars are running AI to keep you on the road, and weapon systems are powered by algorithms designed by engineers making ethical decisions at every step.

When I first started writing about AI, people laughed at me. Some treated me like a sci-fi writer. Others dismissed my ideas outright. I once suggested that AI could automate routine tasks and eliminate up to 25% of keyboard-based jobs like order entry and quoting in our industry—a prediction that raised eyebrows. Someone even said, "We're not all academics like you." But here’s the truth: I'm not an academic in the traditional sense (even though I teach at a great university). I’m an entrepreneurial businessman. I create products, services, systems, and strategies that win.

I don’t have a Ph.D. I have an MBA, curiosity, and a lifetime of leadership in business. I think, I teach, and I write. I bridge academia and business. I ended up in universities because of who I am, not because of a title. After three decades in business, I've learned to see tectonic shifts before others do. That’s leadership. That’s strategy.

Two years ago, companies had the chance to seize competitive advantages through innovation. Many missed the boat. Now, they’re scrambling to catch up, falling behind faster than I’ve ever seen—even faster than during the tech explosion of 1992-2010. Artificial intelligence isn’t just another trend. This is an industrial revolution on the scale of electricity, the automobile, the airplane, the internet, and the smartphone.

People who dismissed these ideas two or three years ago are now calling, citing my work, and asking for advice on adapting to AI's risks and opportunities in their businesses. I am on an industry committee on AI automation.

For those unfamiliar with code, what you’re about to see might make your brain hurt—and that’s okay. I’ll explain everything as we go. This is how adaptation and learning begin. Ready? Let’s dive in.

The Foundation: Building Basic Ethical Guards

Every ethical AI system begins with fundamental safety structures. Rather than abstract guidelines, engineers create concrete mechanisms that enforce ethical behavior. When I talk about virtue ethics, those are abstract concepts that guide us as human in decision making need to become code. These systems work like a sophisticated security network, with multiple layers of protection and monitoring.

At the most basic level, engineers implement safety boundaries through code that continuously evaluates AI behavior. While the code might look simple, it performs crucial ethical oversight. What I will do here is show you the code, then break it down line by line and explain what the code means:

def check_content_safety(response):
    risk_score = assess_risk(response)
    behavioral_patterns = analyze_behavioral_trends(response)
    context_assessment = evaluate_context(response)

    if risk_score > SAFETY_THRESHOLD:
        return generate_safe_alternative(response)
    elif behavioral_patterns.indicates_drift():
        trigger_pattern_review(behavioral_patterns)
    elif context_assessment.requires_caution():
        return add_safety_constraints(response)

    return response        

Breaking Down the Code:

1. def check_content_safety(response): This line defines a function called check_content_safety. A function is like a mini-program that performs a specific task. It takes response (likely some text or message) and checks if it's safe.
2. risk_score = assess_risk(response) This calculates a risk score for the content of the response. The assess_risk(response) function checks if the text contains anything risky (like harmful or inappropriate content). The result is saved in risk_score.
3. behavioral_patterns = analyze_behavioral_trends(response) This checks for unusual behavior in the response. The analyze_behavioral_trends(response) function looks for patterns like sudden changes in tone or style. The results are stored in behavioral_patterns.
4. context_assessment = evaluate_context(response) Now, the function checks the context of the response. The evaluate_context(response) function ensures the reply fits the situation or avoids potential misunderstandings.
5. if risk_score > SAFETY_THRESHOLD: This checks if the risk_score is too high. SAFETY_THRESHOLD is a set limit. If the risk_score exceeds this limit, the content might be unsafe.
6. return generate_safe_alternative(response) If the content is risky, this line creates a safer version of the response. It stops here and returns the safe version instead of the original.
7. elif behavioral_patterns.indicates_drift(): If the content isn’t risky, this checks for behavioral drift — when the response behaves differently than expected (e.g., going off-topic).
8. trigger_pattern_review(behavioral_patterns) If drift is detected, this triggers a review. It might alert a system admin to investigate.
9. elif context_assessment.requires_caution(): If there's no risk or drift, this checks if the context requires caution. Even safe content might need extra care in sensitive situations.
10. return add_safety_constraints(response) If caution is needed, this adds safety rules to the response, like warnings or restrictions.
11. return response If none of the above checks find issues, the function returns the original response.

Summary: This function is like a security guard for AI-generated responses. It checks if the response is risky, unusual, or sensitive. If it finds a problem, it adjusts the response or flags it. If everything looks good, it lets the response pass.

Thanks for reading Ethics and Algorithms! Subscribe for free to receive new posts and support my work.

Beyond Simple Rules: Creating Value-Aware Systems

The real challenge comes in moving beyond simple rules to create systems that understand and implement ethical principles in context. Engineers approach this through value alignment — encoding ethical principles into measurable behaviors.

Consider how we implement value alignment in practice:

class ValueAlignmentSystem:
    def __init__(self):
        self.value_metrics = {
            'helpfulness': ValueMetric('help_score'),
            'honesty': ValueMetric('truth_score'),
            'fairness': ValueMetric('bias_score'),
            'safety': ValueMetric('risk_score')
        }
        self.behavioral_history = BehaviorTracker()
        self.context_analyzer = ContextEvaluator()

    def evaluate_decision(self, proposed_action, context):
        metric_scores = {}
        for value_name, metric in self.value_metrics.items():
            metric_scores[value_name] = metric.measure(
                proposed_action, context, self.behavioral_history
            )

        alignment_score = self.calculate_alignment(metric_scores)

        if not self.meets_standards(alignment_score):
            return self.adjust_action(proposed_action, metric_scores)

        return proposed_action        

Breaking Down the Code:

1. class ValueAlignmentSystem: This creates a class called ValueAlignmentSystem. A class is a blueprint for creating objects that have specific properties and behaviors. This class ensures decisions align with values like honesty, fairness, etc.
2. def __init__(self): This is the constructor method. It runs automatically when creating a new ValueAlignmentSystem object. It sets up the initial values and tools.
3. self.value_metrics = { ... } The system sets up metrics (ways to measure) for different values:

• 'helpfulness': ValueMetric('help_score')
• 'honesty': ValueMetric('truth_score')
• 'fairness': ValueMetric('bias_score')
• 'safety': ValueMetric('risk_score')

1. self.behavioral_history = BehaviorTracker() This tracks the system's past decisions. BehaviorTracker() stores this history to detect patterns over time.
2. self.context_analyzer = ContextEvaluator() This sets up a context analyzer. ContextEvaluator() helps the system understand the situation to ensure decisions make sense.
3. def evaluate_decision(self, proposed_action, context): This defines a method called evaluate_decision. It takes a proposed_action (something the system plans to do) and the context (background info). It checks if the action aligns with the system's values.
4. metric_scores = {} Creates an empty dictionary called metric_scores. This stores scores for each value (helpfulness, honesty, etc.).
5. for value_name, metric in self.value_metrics.items(): Starts a loop to go through each value in self.value_metrics and checks how the action aligns with each.
6. metric_scores[value_name] = metric.measure(proposed_action, context, self.behavioral_history) Measures how well the proposed action aligns with each value, considering past behavior and context. Results are stored in metric_scores.
7. alignment_score = self.calculate_alignment(metric_scores) Calculates an overall alignment score from all the individual scores.
8. if not self.meets_standards(alignment_score): Checks if the alignment score meets the system's standards. If not, adjustments are needed.
9. return self.adjust_action(proposed_action, metric_scores) If the action doesn't meet standards, the system tweaks it for better alignment.
10. return proposed_action If everything aligns, the system approves the original action without changes.

Summary: This system checks if a proposed action aligns with key ethical values. It measures and adjusts decisions to ensure fairness, safety, and honesty.

Continuous Ethical Monitoring: Keeping AI on Track

Beyond value alignment, AI systems need ongoing monitoring to ensure they maintain ethical behavior as they interact with the world. This is where ethical monitoring comes into play.

Consider this example:

class EthicalMonitor:
    def __init__(self):
        self.drift_detector = ValueDriftDetector()
        self.impact_assessor = ImpactAssessment()
        self.pattern_analyzer = BehaviorPatternAnalysis()

    def continuous_monitoring(self, system_actions):
        drift_analysis = self.drift_detector.analyze(system_actions)
        impact_metrics = self.impact_assessor.evaluate(system_actions)
        behavior_patterns = self.pattern_analyzer.detect_patterns(system_actions)

        if any([
            drift_analysis.significant_drift(),
            impact_metrics.negative_impact(),
            behavior_patterns.concerning_patterns()
        ]):
            trigger_review_process(system_actions)        

Breaking Down the Code:

1. class EthicalMonitor: This creates a class called EthicalMonitor. It continuously checks the behavior of AI systems to ensure they remain ethical over time.
2. def __init__(self): This initializes the monitoring system by setting up detectors and evaluators for drift, impact, and patterns.
3. self.drift_detector = ValueDriftDetector() Tracks if the system's behavior starts to drift from its original ethical alignment.
4. self.impact_assessor = ImpactAssessment() Evaluates the potential impact of the AI's decisions on users and society.
5. self.pattern_analyzer = BehaviorPatternAnalysis() Looks for unusual patterns in AI behavior that could indicate ethical issues.
6. def continuous_monitoring(self, system_actions): Defines a method to regularly check AI actions for ethical compliance.
7. if any([...]): If any of the drift, impact, or behavior checks indicate problems, the system triggers a review process.

Summary: This system ensures that AI remains ethically aligned as it operates in dynamic environments, identifying potential ethical problems in real-time.

Learning from Edge Cases: Adaptive Ethical Systems

Even with the best planning, AI systems will encounter situations developers didn’t anticipate. Ethical AI systems need to learn from these edge cases while maintaining ethical principles.

Here’s how we implement this:

class EthicalLearningSystem:
    def process_edge_case(self, case, outcome):
        case_analysis = analyze_case_factors(case)
        ethical_implications = assess_ethical_impact(outcome)

        if ethical_implications.requires_adjustment():
            update_decision_boundaries(case_analysis)
            retrain_value_models(ethical_implications)
            log_learning_event(case, outcome, adjustments_made)        

Breaking Down the Code:

1. class EthicalLearningSystem: This class enables AI systems to adapt and learn from unexpected situations (edge cases) while preserving ethical integrity.
2. def process_edge_case(self, case, outcome): Defines a method to process new, unexpected scenarios and their outcomes.
3. case_analysis = analyze_case_factors(case) Analyzes the details of the unusual case.
4. ethical_implications = assess_ethical_impact(outcome) Evaluates the ethical consequences of the system's decision.
5. if ethical_implications.requires_adjustment(): If ethical issues are found, the system takes corrective actions.
6. update_decision_boundaries(case_analysis) Adjusts the system’s boundaries to prevent similar ethical issues in the future.
7. retrain_value_models(ethical_implications) Retrains the AI models based on new ethical insights.
8. log_learning_event(case, outcome, adjustments_made) Logs the learning event for future reference and accountability.

Summary: This system helps AI learn from real-world complexities while upholding ethical standards.

Conclusion

There you have it. The code you were just introduced to is part of your life. Implementing ethical AI isn't just a technical challenge—it's a fundamental requirement for responsible AI development. Engineers aren't just writing code; they're creating systems that make countless decisions affecting real people's lives. Understanding how to properly implement ethical principles in AI systems is crucial for anyone working in AI development or deployment.

Thanks for reading,

Kevin

[Keywords] AI ethics implementation, ethical AI engineering, AI safety systems, value alignment, AI governance, responsible AI development

Glossary of Key Terms:

• Function: A reusable block of code that performs a specific task.
• Class: A blueprint for creating objects with specific properties and behaviors.
• Loop: A programming structure that repeats a set of instructions until a condition is met.
• Dictionary: A data structure that stores information in key-value pairs.
• Context: The situation or environment in which an AI makes decisions.
• Alignment Score: A measure of how well a proposed action fits with established ethical values.
• Behavioral Drift: When an AI’s behavior starts to deviate from expected ethical norms.

This glossary will help readers unfamiliar with coding terminology understand the technical aspects of ethical AI implementation.

LATEST AI ETHICS ISSUES

- Google Abandons AI Weapons Ban: In a major policy shift on February 4, 2025, Google removed its longstanding commitment not to use AI for weapons and surveillance. The company's updated ethics guidelines now frame AI development around national security, economic growth, and democratic values. The policy change has sparked significant internal protest at Google, with employees flooding internal message boards with criticism. Staff members are particularly concerned about the company's increasing involvement in military and defense contracts. Google's reversal of its AI ethics stance could influence other tech companies to reconsider their positions on AI applications in weapons and surveillance. The move reflects growing competition in AI development and changing perspectives on national security priorities. AI ethics experts and campaigners have expressed serious concerns about Google's policy change, highlighting potential risks to human rights and the need for continued ethical oversight in AI development.

- UNESCO Advances AI Ethics Globally Conducting an AI ethics workshop in Cuba focusing on equity, rights, and inclusion; working with Cambodia on Ethics of AI Readiness Assessment to ensure responsible AI development. Over 60 UNESCO member countries are currently assessing AI ethics using the RAM methodology.

Articles I have been Reading

[1] https://www.eweek.com/news/google-updates-ai-ethics-guidelines/

[2] https://www.ibtimes.co.uk/google-reverses-stance-now-permits-weapons-development-revised-ai-guidelines-competition-heats-1730790

[3] https://www.scrippsnews.com/science-and-tech/artificial-intelligence/google-removes-pledge-not-to-use-ai-for-weapons-or-surveillance

[4] https://www.azernews.az/region/237378.html

[5] https://www.cnn.com/2025/02/04/business/google-ai-weapons-surveillance/index.html

[6] https://www.unesco.org/en/articles/unesco-holds-workshop-ai-ethics-cuba

[7] https://www.hrkatha.com/news/googles-ai-ethics-shift-sparks-employee-revolt/

[8] https://www.unesco.org/en/articles/cambodias-ethics-ai-readiness-assessment-advanced-strategic-multi-stakeholder-consultation

[9] https://www.bbc.com/news/articles/cy081nqx2zjo

[10] https://www.unesco.org/en/articles/harnessing-emerging-technologies-sustainable-development-africa-including-through-implementation

[11] https://www.personneltoday.com/hr/ai-ethics-hr-adoption-cipd/

[12] https://gulfbusiness.com/deepfest-2025-ai/

[13] https://www.ccn.com/news/technology/google-revised-ai-ethics-military-surveillance/

[14] https://dig.watch/newsletters/dw-monthly/digital-watch-newsletter-issue-96-february-2025

[15] https://www.washingtonpost.com/technology/2025/02/04/google-ai-policies-weapons-harm/

[16] https://hibiscuscoastapp.nz/NewsStory/new-zealands-role-in-ethical-ai-development/67a3d2e210eb2c002d554429

[17] https://english.cw.com.tw/article/article.action?id=3950

[18] https://www.itweb.co.za/article/sona-2025-ai-and-south-africas-leadership-why-the-national-ai-strategy-cant-wait/JN1gP7OAL8OqjL6m

[19] https://cybernews.com/news/google-ai-ethics-paradox/

[20] https://www.wam.ae/article/bi00jey-from-ethics-gen-z%E2%80%99s-trillion-economy-sef-2025

About Kevin Baker

I’m Kevin Baker—The American in Australia! From boardrooms to classrooms, and even my early days as a social entrepreneur, I’ve learned one truth: Wealth isn’t just about money—it’s about growth, freedom, and impact. Let me show you how to build yours.

Let’s Connect! ?? Contact Me ?? Explore My Website, Newsletters, Podcast & Social Media. (Link Tree)

?? Substack Notes: If you haven’t explored Substack Notes yet, it’s where I share quick thoughts and ideas that may not make it into a full newsletter—but sometimes, these spark the next big conversation.

One recent note: “AI is Making Perfection Worthless. But Human Imperfection? That’s Priceless.” AI is getting faster, smarter, and more efficient. It can write, code, and optimise better than ever. But the more AI perfects things, the more we crave imperfection. It can’t replicate the flaws that make something real—the quirks that turn craft into art. The future of work won’t belong to perfection. It will belong to the irregular, the personal, and the deeply human. ?? Read the entire note here.

?? Mastermind Advisory Groups Now Open! Imagine having five powerhouse leaders from diverse industries in your corner—pushing you, holding you accountable, and sharing their strategies for massive growth. That’s what the Kevin Baker Mastermind Advisory Groups are all about.

?? Only 5 spots left for our next cohort.. Don’t miss your chance to unlock your next big breakthrough. Learn more & apply here.

??? Let’s Talk Business (Resource Hub) I know what it’s like to juggle big ideas with limited time—that’s why I’ve poured every spare hour into developing a new resource hub that’s laser-focused on helping you grow.

?? Courses include:

• Kevin Baker—will announce at launch very soon!
• Pretty Darn Awesome Kids (Autism-PDA Parenting) by Katie Baker. My wife is a former RN, and holds a Master of International Public Health degree from UNSW. She advises families how to maximise NDIS funding (fee based), holds live events on parenting neurodivergent children, and will be releasing her courses on the new hub.

Stay tuned for the official launch!

?? Consulting & Advisory Services I help companies across Australia and the USA tackle their biggest challenges—from scaling startups to streamlining operations in mature businesses. One client increased their revenue by 20% in just six months by clarifying what their strategy actually is, then executing it by building a systems driven, team based, analytics-driven approach. Let’s make your business the next success story.

Board Memberships & Governance I’m a professional board member with a Certificate in Governance Practice from the Governance Institute of Australia. If your company needs governance advisory or board-level strategy input, let’s connect.

?? Contact me for consulting or governance advisory.

?? Let’s Build Something Together Your next breakthrough is just a click away. Whether it’s business growth, personal development, or family support, I’ve got the tools, insights, and strategies to help you thrive.

?? Ready to take the next step? Book a free discovery call today.

?? Coming Soon: The Webstore! We’re excited to announce our webstore is launching soon—featuring business tools, family resources, and exclusive merch you won’t find anywhere else. Stay tuned for updates!